ref: 8f75d0a0077f7fd4e8d47f47231b6e20f86166cc
dir: /include-demo/openimgui.h/
#ifndef OPENIMGUI_IMPL
extern float omg_cursorpos[2]; //Defaults to zero
extern float omg_cursorpos_presuck[2]; //Defaults to zero
extern int omg_cursor_has_been_sucked;
extern int omg_cursor_was_inside; //Set
extern float omg_buttonjump[2]; //Defaults to zero
// Setting for users using
extern int omg_bstate_old;
extern int omg_udlr_old[4];
extern int omg_udlr[4];
// cursor button
extern int omg_cb; //Set to zero every iteration.
#endif
#ifndef OPENIMGUI_H
#define OPENIMGUI_H
#include <math.h>
//PROTOTYPE FOR THE OPENIMGUISTANDARD PROPOSAL
//Licensed to you under the CC0 license.
//This is the standard for an intuitive immediate-mode gui specification which gracefully solves many of the shortcomings of
//other immediate mode gui standards.
//1) How elements are drawn across different environments
//2) How keyboard/gamepad cursor navigation is handled
//3) How the same GUI rendering code can be transported between backends.
//This is a standard for immediate mode GUI elements which can be implemented anywhere and gracefully decreases in feature level based on platform.
//If your target platform can render text and it can render boxes, then it can run openimgui.
// The screen's top left corner is 0,0 and bottom right is 1,1
// All coordinates and dimensions are specified relative to that.
//HOW CURSOR BUTTON IS HANDLED~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//Beginning of your frame...
//omg_cb = 0;
//if(just_touched || just_mouseleftbuttondown || just_button_down) omg_cb = 1; //Pressed!
//if(just_released_touch || just_mouseleftbutton up || just_button_up) omg_cb = 2; //Released!
//Gui code this frame...
//HOW CURSOR POSITION IS HANDLED:
// On platforms with touch or mouse input, the polling of cursor position will occur like this~~~~~~~~~~~~~
// omg_cursor_has_been_sucked = 0;
// omg_cursorpos[0] = device_cursorpos.x / (float) screenWidth;
// omg_cursorpos[1] = device_cursorpos.x / (float) screenHeight;
// Clamp the cursorpos (if necessary)
// omg_cursorpos[0] = omg_clampf(omg_cursorpos[0]);
// omg_cursorpos[1] = omg_clampf(omg_cursorpos[1]);
// omg_cursorpos_presuck[0] = -1;
// omg_cursorpos_presuck[1] = -1;
// On platforms which use buttons to navigate menu elements...~~~~~~~~~~~~~
// omg_cursor_has_been_sucked = 0;
// if(buttonleft) omg_cursorpos[0] -= omg_buttonjump[0];
// if(buttonright) omg_cursorpos[0] += omg_buttonjump[0];
// if(buttonup) omg_cursorpos[1] -= omg_buttonjump[1];
// if(buttondown) omg_cursorpos[1] += omg_buttonjump[1];
// Clamp the cursorpos
// omg_cursorpos[0] = omg_wrapf(omg_cursorpos[0]);
// omg_cursorpos[1] = omg_wrapf(omg_cursorpos[1]);
// omg_cursorpos_presuck[0] = omg_cursorpos[0];
// omg_cursorpos_presuck[1] = omg_cursorpos[1];
// HOW BUTTON SUCKING WORKS ~~~~~~~~~~~~~~
// On platforms without cursor input such as game consoles, there needs to be an ergonomic way to navigate menus.
// This is achieved by simulating a virtual mouse cursor in the game and "Sucking" it into the closest sucking box.
// We keep track of the cursorposition every frame as well as the position before an attempt to "suck" it has been made.
// This allows us to determine (By testing, for every graphical object) whether or not the cursorposition should be "sucked" into
// the graphical object.
// Normalized cursor position
#ifdef OPENIMGUI_IMPL
float omg_cursorpos[2]; //Defaults to zero
float omg_cursorpos_presuck[2]; //Defaults to zero
int omg_cursor_has_been_sucked;
int omg_cursor_was_inside; //Set
float omg_buttonjump[2]; //Defaults to zero
// Setting for users using
int omg_bstate_old = 0;
int omg_udlr_old[4] = {0,0,0,0};
int omg_udlr[4];
// cursor button
int omg_cb; //Set to zero every iteration.
#endif
//Used for determining the closest button in sucking mode.
static inline float omg_sqrlinelength(float x1, float y1, float x2, float y2){
return ((x1-x2) * (x1-x2) + (y1-y2) * (y1-y2));
}
//Used for clamping cursor position to the screen.
static inline float omg_clampf(float x){
return (x>1.0)?1.0: (x<0.0)?0.0:x;
}
//Used for wrapping the cursor position to the screen in button cursor mode.
static inline float omg_wrapf(float x){
float f = fmod(x, 1);
if(f<0.0) (f = 1.0 + f);
return f;
}
static inline void omg_update_keycursor(int _up, int _down, int _left, int _right, int bstate){
omg_cursor_was_inside = 0;
int up = _up && ! omg_udlr_old[0];
int down = _down && ! omg_udlr_old[1];
int left = _left && ! omg_udlr_old[2];
int right = _right && ! omg_udlr_old[3];
omg_udlr[0] = up;
omg_udlr[1] = down;
omg_udlr[2] = left;
omg_udlr[3] = right;
omg_udlr_old[0] = _up;
omg_udlr_old[1] = _down;
omg_udlr_old[2] = _left;
omg_udlr_old[3] = _right;
omg_cursor_has_been_sucked = 0;
omg_cursorpos_presuck[0] = omg_cursorpos[0];
omg_cursorpos_presuck[1] = omg_cursorpos[1];
if(up) omg_cursorpos[1] -= omg_buttonjump[1];
if(down) omg_cursorpos[1] += omg_buttonjump[1];
if(left) omg_cursorpos[0] -= omg_buttonjump[0];
if(right)omg_cursorpos[0] += omg_buttonjump[0];
//Clamp the cursorpos
omg_cursorpos[0] = omg_wrapf(omg_cursorpos[0]);
omg_cursorpos[1] = omg_wrapf(omg_cursorpos[1]);
omg_cursorpos_presuck[0] = omg_cursorpos[0];
omg_cursorpos_presuck[1] = omg_cursorpos[1];
//printf("BEGIN! Cx = %f, Cy = %f\n", omg_cursorpos[0], omg_cursorpos[1]);
omg_cb = 0;
if(bstate && !omg_bstate_old) omg_cb = 1;
else if (!bstate && omg_bstate_old) omg_cb = 2;
omg_bstate_old = bstate;
}
//for mouse cursors and touch input.
static inline void omg_update_mcursor(float ncx, float ncy, int bstate){
omg_cursor_has_been_sucked = 0;
omg_cursor_was_inside = 0;
omg_cursorpos[0] = ncx;
omg_cursorpos[1] = ncy;
// Clamp the cursorpos (if necessary)
omg_cursorpos[0] = omg_clampf(omg_cursorpos[0]);
omg_cursorpos[1] = omg_clampf(omg_cursorpos[1]);
omg_cursorpos_presuck[0] = -1;
omg_cursorpos_presuck[1] = -1;
omg_cb = 0;
if(bstate && !omg_bstate_old) omg_cb = 1;
else if (!bstate && omg_bstate_old) omg_cb = 2;
omg_bstate_old = bstate;
}
static inline int omg_boxtest(float x, float y, float xdim, float ydim, float cx, float cy){
if((x <= cx) &&
(x+xdim >= cx) &&
(y <= cy) &&
(y+ydim >= cy))
return 1;
return 0;
}
static inline int omg_box_retval(float x, float y, float xdim, float ydim){
if(omg_cursorpos_presuck[0] == -1)
return omg_boxtest(x,y,xdim,ydim, omg_cursorpos[0],omg_cursorpos[1]);
return omg_boxtest(x,y,xdim,ydim, omg_cursorpos_presuck[0],omg_cursorpos_presuck[1]);
}
static inline void omg_box_suck(float x, float y, float xdim, float ydim, int sucks, float buttonjumpx, float buttonjumpy){
if(omg_cursorpos_presuck[0] != -1 && sucks){ //Do not attempt to suck if this graphical element does not suck or sucking is not enabled.
int btest = omg_boxtest(x,y,xdim,ydim, omg_cursorpos_presuck[0], omg_cursorpos_presuck[1]);
if(!omg_cursor_has_been_sucked){
//We are free to try to suck up the cursor without a check.
omg_cursorpos[0] = x + xdim/2.0;
omg_cursorpos[1] = y + ydim/2.0;
omg_cursor_has_been_sucked = 1;
omg_buttonjump[0] = buttonjumpx;
omg_buttonjump[1] = buttonjumpy;
if(btest) omg_cursor_was_inside = 1;
//puts("Initial grab...\n");
//printf("Cx = %f, Cy = %f\n", omg_cursorpos[0], omg_cursorpos[1]);
} else if (
(!omg_cursor_was_inside && //Cursor was not inside.
omg_sqrlinelength(x+xdim/2.0, y+ydim/2.0, omg_cursorpos_presuck[0], omg_cursorpos_presuck[1]) <
omg_sqrlinelength(omg_cursorpos[0], omg_cursorpos[1], omg_cursorpos_presuck[0], omg_cursorpos_presuck[1])
) || //Cursor was inside, if it's inside this one as well, pick the closest.
(!omg_cursor_was_inside && btest) ||
(
btest &&
omg_sqrlinelength(x+xdim/2.0, y+ydim/2.0, omg_cursorpos_presuck[0], omg_cursorpos_presuck[1]) <
omg_sqrlinelength(omg_cursorpos[0], omg_cursorpos[1], omg_cursorpos_presuck[0], omg_cursorpos_presuck[1])
)
){
//The box is closer than the current suck position.
omg_cursorpos[0] = x+xdim/2.0;
omg_cursorpos[1] = y+ydim/2.0;
omg_cursor_has_been_sucked = 1;
omg_buttonjump[0] = buttonjumpx;
omg_buttonjump[1] = buttonjumpy;
//if(boxtest(x,y,xdim,ydim)) omg_cursor_was_inside = 1;
omg_cursor_was_inside = omg_boxtest(x,y,xdim,ydim, omg_cursorpos_presuck[0], omg_cursorpos_presuck[1]);
//puts("Found a different button!\n");
//printf("Cx = %f, Cy = %f\n", omg_cursorpos[0], omg_cursorpos[1]);
}
}
}
// OMG_BOX:
// Draws a box on the screen.
// Returns whether or not the cursor was inside it this frame (NOT IF IT GOT __SUCKED__ INSIDE IT!)
// x,y are the top left corner.
// xdim, ydim, are the width and height of the box.
// hints is a set of implementation-specific parameters describing the nature of how the box is drawn,
// sucks indicates whether or not the cursor position is "sucked" into the button (See: HOW BUTTON SUCKING WORKS)
// buttonjumpx and buttonjumpy are the amount by which the cursor will jump in X and Y when pressing the menu navigation arrows.
// The return value is determined like this:
// if(omg_cursorpos_presuck[0] == -1) return omg_boxtest(omg_cursorpos) else
// return boxtest(omg_cursorpos_presuck)
// The suck test works like this:
// if(omg_cursorpos_presuck[0] != -1 && sucks){ //Do not attempt to suck if this graphical element does not suck or sucking is not enabled.
// if(!omg_cursor_has_been_sucked){ //We are free to try to suck up the cursor without a check.
// omg_cursorpos[0] = x+xdim/2.0;
// omg_cursorpos[1] = y+ydim/2.0;
// omg_cursor_has_been_sucked = 1;
// omg_buttonjump[0] = buttonjumpx;
// omg_buttonjump[1] = buttonjumpy;
//} else if (omg_sqrlinelength(x+xdim/2.0, y+ydim/2.0, omg_cursorpos_presuck[0], omg_cursorpos_presuck[1]) <
// omg_sqrlinelength(omg_cursorpos[0], omg_cursorpos[1], omg_cursorpos_presuck[0], omg_cursorpos_presuck[1])){ //The box is closer than the current suck position.
// omg_cursorpos[0] = x+xdim/2.0;
// omg_cursorpos[1] = y+ydim/2.0;
// omg_cursor_has_been_sucked = 1;
// omg_buttonjump[0] = buttonjumpx;
// omg_buttonjump[1] = buttonjumpy;
//}}
//When sucking is enabled (omg_cursorpos_presuck[0] != -1) the box test will be performed on cursorpos_presuck.
//You can use the above static inline functions as a reference for your implementation.
int omg_box(float x, float y, float xdim, float ydim, int sucks, float buttonjumpx, float buttonjumpy, int hints);
// OMG_TEXTBOX:
// Draws a box... with text in it
// All the args are the same, and its return value is the same, except now it can draw text.
// It should handle all the same hints as omg_box.
// the hintstext variable should handle all
// The textsize is an implementation-specific indication of how large the text in the box should be.
// The x and y dimensions of the box are automatically deduced from text.
// Text containing newlines will extend the Y dimension of the box,
// and the longest line of text will determine the x dimension of the box.
// Otherwise, it is functionally identical to omg_box.
int omg_textbox(float x, float y, const char* text, int textsize, int sucks, float buttonjumpx, float buttonjumpy, int hints, int hintstext);
#endif