ENIGMA Development Environment

Changelog:
1.1
-Added new spline functions that have control points
-Made spline_begin() function use vectors and stacks. This decreases memory consumption and allows nesting (several _begin() and _end() inside one another).
-Added new _end() function that optimizes the curve (reduces vertexes based on point distance).
-Added anti-aliasing functions.

Description: These are functions for drawing curves. Both Bezier and splines. These functions allow drawing them with specific widths, with alpha and color blending, as well as getting points on the curve.

Functions:void draw_bezier_quadratic(float x1,float y1,float x2,float y2,float x3,float y3);
void draw_bezier_cubic(float x1,float y1,float x2,float y2,float x3,float y3, float x4, float y4);
void draw_set_curve_color(int c1, int c2);
void draw_set_curve_alpha(float a1, float a2);
void draw_set_curve_mode(int mode);
void draw_set_curve_detail(int detail);
void draw_set_curve_width(int width);
void draw_set_antialiasing(bool enable, int qual);
float draw_bezier_quadratic_x(float x1,float y1,float x2,float y2,float x3,float y3, float t);
float draw_bezier_quadratic_y(float x1,float y1,float x2,float y2,float x3,float y3, float t);
float draw_bezier_cubic_x(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float t);
float draw_bezier_cubic_y(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float t);
void draw_spline_part(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, int c1, int c2, float a1, float a2);
void draw_spline2c(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
void draw_spline3(float x1, float y1, float x2, float y2, float x3, float y3);
void draw_spline3c(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float x5, float y5);
void draw_spline4(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
void draw_spline4c(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float x5, float y5, float x6, float y6);
void draw_spline_begin(int mode);
int draw_spline_vertex(float x, float y);
int draw_spline_vertex_color(float x, float y, int col, float alpha);
void draw_spline_end();
int draw_spline_optimized_end();Most functions are self explanatory (if not, then the example shows most of them at work). Only things I should note is about draw_spline_part, which is not actually meant to be used. It is used in other spline functions and that is the one that actually draws the spline. You can use it separately if you wish, thou then you need to call glBegin and glEnd, because that function only returns vertexes.
Another function I should note is draw_spline2c, it draws a line between two points, but accounts for two control points that shape the actual line. The rest of the spline drawing functions that have c at the end act the same. The first and the last points are control points.
draw_spline_begin() function needs at least 4 points to draw one line. The first and the last point is a control point.
draw_spline_optimized_end() function should be used in some cases like when there are a lot of points and many of them can be close together. This function checks the distance of the two points and then reduces the vertex count as needed. The maximum vertex count is still pr_curve_detail (set by draw_set_curve_detail()). This function returns the vertex number drawn.

Download: GMK and .h/.cpp files can be downloaded from attachments. Exe version of the example (just to check it out or if it doesn't work for you) can be downloaded here: http://www.host-a.net/u/harrikiri/curvesexample.zip.

Installation: As Enigma doesn't have an easy 2 click extension mechanism now (or will never have?!?), you need to put these files in manually. Copy GScurves.h and GScurves.cpp into Enigma\ENIGMAsystem\SHELL\Graphics_Systems\OpenGL (preferably). Then open: Enigma\ENIGMAsystem\SHELL\SHELLmain.cpp and put #include "Graphics_Systems/OpenGL/GScurves.h" into line 63 or so (after #if ENIGMA_GS_OPENGL). Then either use bash script located in Enigma\ENIGMAsystem\SHELL\Developer\automake.sh, or if you are on Windows (like me), then just open Enigma\ENIGMAsystem\SHELL\Graphics_Systems\OpenGL\Makefile and add:

.eobjs_$(MODE)/GScurves.o: GScurves.cpp OpenGLHeaders.h
   g++ -c GScurves.cpp      -o .eobjs_$(MODE)/GScurves.o $(FLAGS)

To somewhere in the top. And: ".eobjs_Run/GScurves.o" everywhere at the bottom (just look where similar action is done.

Notice: You need to actually do additional things to run the example or use this code as intended. First, you need to fix merge_color function which is buggy in the current repo. To fix this, find and open GScolors.cpp, find merge_color function and replace the code with this:
int merge_color(int c1,int c2,double amount)
{
    amount = amount > 1 ? 1 : (amount < 0 ? 0 : amount);
    return
    (unsigned char)(fabs(__GETR(c1)+(__GETR(c2)-__GETR(c1))*amount))
    | (unsigned char)(fabs(__GETG(c1)+(__GETG(c2)-__GETG(c1))*amount))<<8
    | (unsigned char)(fabs(__GETB(c1)+(__GETB(c2)-__GETB(c1))*amount))<<16;
}Second, you need to add a new math function, which I didn't just insert as a script for some reason. Its lerp (linear interpolation) and seemed useful as a standard function. Open mathnc.cpp and put this somewhere:
double lerp(double x, double y, double a) { return x + ((y-x)*a); }Also, open mathnc.h and add the header:
double lerp(double x, double y, double a);I think this should be all. Maybe I have forgotten something, so if you get an error post it here.

Example controls: You can scroll through rooms with left and right arrows. In the third room (where there is initially just a black screen) you can draw a curve with your mouse. Left click to add a point, or hold right button to add a lot of points. In the last room you can move that jelly thing to your mouse with left click and increase/decrease detail with up and down arrows. Room system seems buggy, so I couldn't find a way to return back to previous rooms. Its just restarts from the first room when you press left arrow. Press number keys to disable, enable and change quality of anti-aliasing. 1-Disabled. 2-Enabled, fastest. 3-Enabled, nicest. 4-Enabled, don't care.

To-Do:
-Add new functions to get points on splines

Thanks to LSnK for inspiring me to make this for Enigma, as well as making that beautiful example (which modified code is used in this example too).

Indeed, I chose not to use a custom vertex buffer to render primitives, and nested glBegin()s are invalid. I am unsure why you would be drawing a circle inside your primitive calls in the first place, but if you can make a case for it I'd be happy to use a dynamic array for a custom VBO (another 1980 GL spec that Intel refuses to support).

Well I had code like this:draw_spline_begin(pr_linestrip);
for (int i=0; i<points; i++){
    draw_spline_add_point_color(ar[i,0],ar[i,1],ar[i,2],ar[i,3]);
    draw_circle(ar[i,0],ar[i,1],5,1);
}
draw_spline_add_point(ar[points-1,0],ar[points-1,1]);
draw_spline_end();So I draw a point and also draw a circle at that same point. I can, of course, make two "for cycles" for this, but that would be slower. Maybe not in this case (where point number is like 512 max), but in other cases where you draw more stuff together. Either way, how would dynamic arrays work? Is it the same as in the link I posted? Where you just create new array every time you need more space?

Thanks. I have create splines, but I think I use some very bad method. But that was the only method I could easily grasp. Thou that method allows making a spline with infinite points, so that's nice. Now I am thinking of some method to allow user to pass thous points. I can't use ds_lists as LSnK does (the creator of curves extension), because they are not implemented yet (at least I think so). I could use _begin, _add_point(x,y), and _end thou. So I am trying to do so.

Solved: No need to read this unless you're bored.

I am playing with some curves (sounds dirty doesn't it?) and I have a problem almost totally unrelated to that. For some eye candy I usually use cos/sin and current_time to get oscillation. I used current_time and it always returned 0, then I found out that actually current_time is not defined anywhere (and Enigma doesn't report non existing variables, they just assume 0, and that is bad (people don't suggest to use "Threat undefined variables as 0" for a reason)). Anyway, I went to implement it myself thinking it is easy. Found key_game_globals.h, and uncommented "extern double      current_time;". Then went into WINDOWSmain.cpp and modified a small part to this:extern double fps, current_time;
namespace enigma {
  clock_t lc;
  void sleep_for_framerate(int rs)
  {
    clock_t nc = clock();
    int sdur = 1000/rs - 1 - (nc - lc)*1000 / CLOCKS_PER_SEC;
    if (sdur > 0)
    {
        Sleep(sdur);
        fps = room_speed;
    }
    else
    {
        fps = CLOCKS_PER_SEC / (nc - lc);
        if(fps > room_speed){ fps = room_speed; }
    }
    lc = nc;
    current_time = clock() / double(CLOCKS_PER_SEC) * 1000;
  }
}So now current_time holds ms till the program launched. In GM it actually holds the number of ms the system has started, but whatever. Now whenever I use "extern double current_time;" in .cpp I can get that number and it works great. But the problem is that when I use string(current_time) in Enigma it just still returns 0. Did I miss a place to put it?
I also uncommented the line in GAME_GLOBALS.h to "double      current_time;".

edit: I did everything right. Just didn't occur to me to restart LGM (I know I need to do this when I update header files, but not when I update .cpp files).

Ok. I knew that Sturcts could be possible, but as I never used them I didn't know.

1) Yes, I was thinking about how it could be applied, but then I realized that doing so would completely alienate a useful function: GL_WRAP based tiling. Honestly, I'm not entirely positive how to justify a check for texbordx and y (As you mentioned) against 1 just to determine if tiling is possible... I've been giving it some thought, but I'm not yet confident enough to just go through with it.

And where exactly we use GL_WRAP? That worked only with power of two textures anyways, and that's the reason why our tiling functions use for loops and quads. The pluses for this I think are many. In Mikes example they could reduce texture size from 28 512x512 to 17 512x512. For bigger games that would be a much larger gain. If we want to launch Enigma games on mobile devices, then this, sadly, is a must.

Glad to hear its so close.

I too don't think you can make argument type resolution, as script arguments in GM can not only be a number or a string, but it can be both (in one place you add a number, the next place that argument is a string, and the script is made to account for that). I don't usually code like that, so argument type resolution would work in my case, but I am not sure if that actually makes any difference in speed. And yes, I am sure what I said didn't make much sense.

I am aware of Design Mode. I am actually here for a while now. I am registered in April 2008. I remember some screens of it a while back.

And yes, I now tried adding draw_primitive_set_line_width before _begin and it works. I was 150% sure that I did try that before thou... weird.

And how tha hell you got that sweet division in your post.

---

edit: Found it.

I can't think of any reason "if (nx*nx+ny*ny<radius*radius){" would behave that way. If you like, you can look at IDE_EDIT_objectfunctionality.h and find how the faulty code is exported. If you see something wrong with it, tell me and I'll probably be able to diagnose the problem.

I checked and it parses at that point correctly. The problem was with with() statement and arguments. The beginning of the code looked like this:with (obj_controller){
int i,c, radius, xx, yy, nx, ny, dir,col, nid;
xx=argument0;
yy=argument1;
radius=argument2;And it parsed like this:  with(obj_controller)
  {
    int i, c, radius, xx, yy, nx, ny, dir, col, nid;
    xx = enigma::varaccess_argument0(int(self));
    yy = enigma::varaccess_argument1(int(self));
    radius = enigma::varaccess_argument2(int(self));As you can see it tries to get variables argument0, argument1 and 2 from obj_controller. As those variables don't exist it returns 0 for some reason (even thou it should return an error no?).
When I change it to this:int i,c, radius, xx, yy, nx, ny, dir,col, nid;
xx=argument0;
yy=argument1;
radius=argument2;
with (obj_controller){It parses correctly.
So basically, arguments don't work inside with() statements. Also other.argument0 doesn't work either, it also returns 0.

edit: Also, a script is generated for all objects that uses it? Isn't that more bad than just creating one and making all objects use it?