Aros/Developer/OpenGL

< Aros

IntroductionEdit

Far better using SDL's GL additions or ....


3D Engine - Ogre, Crystal Space, Torque3D, GamePlay 3D,

3D Physics - Qu3e, [ Bullet],

3D Game Engine - [https://github.com/showcases/game-engines List of},


The Amiga's first introduction to hardware enhanced 3D was Warp3D. This was followed by an open source(software based) equivalent called Wazp3D A Wazp3D adaptation to AROS from Matthias Rustler appeared on December 2007. During 2009 Krzysztof "Deadwood" Smiechowicz ported version 7.5 of MESA 3D to AROS. MESA 3D provides a generic OpenGL implementation. Then he added hardware 3D acceleration capabilities to AROS with his port of Gallium3D for MESA 3D. Then on September 2011 Wazp3D was linked to Mesa 3D for hardware enhanced 3D.


  • Framebuffer - alpha, stencil, depth
  • Fragment - texturing, fog,
  • Geometry - primitives (dots, lines, polygons triangle/quad), clipping
  • Vertex - transform and lighting
  • App -


Loaders may be required to help with different versions needs Lua based loading libraries with extensions, extensions,


Considered deprecated (ie not advised using or missing/removed)

GL1.1 - Fixed Functions - glNormalPointer, glColorPointer and glVertexPointer were introduced. Nearly all of the old ID software are OpenGL 1.1 + extensions

GL1.3 -

GL1.4 - fragment support added

GL1.5 - VBOs added


GL2.0 - Vertex / Fragment shaders introduced - WebGL minimum - GLSL shading language -

       deprecated = glMatrixMode glMult/LoadMatrix glRotate/Translate/Scale glPush/PopMatrix glBegin/End glVertex glTexCoords
                    glLight glMaterial glPush/PopAttrib 

GL2.1 - 2006 - last appearance of some matrix functions/stacks - PBOs Pixel buffer objects -


If you want to be able to run on hardware incapable of OpenGL 3.0, then suggest that you not write applications for OpenGL 3.0. Many of the features of 3.0 that can be used on older hardware are backported via extensions. So instead of writing a 3.x application, you should be writing a 2.1 application that is able to use certain extensions. So just code to the GL 2.1 spec instead. You can always research the calls and features that have been since deprecated and just avoid using them in a pure 2.1 program

general method is to have different rendering paths for different features. You detect the version number. If it's one thing, you use one rendering path. If it's lower, you use another. Etc. You can do fine-grained checking by checking for the presence of certain extensions.



Minimum advised starting point for new apps which arrived with Mesa 12 ported to AROS which opened access to the following (hardware support permitting)

Gl3.0 - 2008 - Geometry shaders - Vertex Array Objects (VAOs) ie GL_ARB_vertex_array_object. Older versions need to do more vertex setup work when drawing an object, rather than setting them up once and just binding the VAO. Modern OpenGL enforces you to write your own matrices and pass those manually into shader programs. use programmable function pipelines

GL3.1

GL3.3

GL4.0 - 2010 - Tesselation shaders - Image load/store and atomic counters are probably the biggest ones (this includes shader storage buffers too), though simultaneously the least advertised. Shaders get to write/read from images and buffers directly, though there are a lot of caveats and synchronization issues to understand about doing this. introduces an additional pair of shader stages: one that decides how much to tessellate a primitive, and the other to decide how to generate the new values from the tessellated primitive.

GL4.1 - 2010 - OpenGL es 2 - Subroutines are an interesting but often overlooked feature. Basically, you can attach subroutines to shader programs like uniforms. So you could use the same basic program that will run a lighting function, but you can swap lighting functions without changing the program. The basic program would fetch textures, figure out what the diffuse/specular/etc material parameters are, determine the normal and lighting parameters, and pass that to the subroutine. allows you to dynamically piece together different fragments of shaders. You can more or less attach a function to a specific bind point in a program.

GL4.2 - 2011 -

GL4.3 - 2012 - Compute shaders - openGL ES 3 compatibility -

GL4.4

GL4.5


Open Scene Graph claims OGL 3.x and 4.x support, but has some kind of weird LGPL based hybrid license. It's C++ based and they consider subclassing to be outside of the scope of the license. The hybrid LGPL-derived license has an exception which allows the shipment of statically linked binaries, so that eliminates one of the major objections to using the LGPL in commercial work.

Ogre has a new 3.3 renderer that seems to be a work in progress. Forum entries seem to indicate that "modern" shader architecture stuff for both OpenGL and DX11 are WIP. MIT license.

G3D has OpenGL 3.3 but only for Windows and OS X. They used to have Linux support but discontinued it due to too many distros to deal with. A recent mailing list post says they want to reinstate the support. BSD license.

ClanLib seems to support 3.3..4.3 but may not build. Zlib license.

Irrlicht claims OpenGL 3.x on their features page. Zlib license.

Cube 2 looks like OpenGL 2.x. Someone's working on something called Tesseract which might have more "dynamic lighting" capabilities, but it's unclear that this means 3.x+. Zlib license.


the bare minimum of a "modernized" engine are

1. Conditional rendering support (if the engine relies on occlusion queries, which many engines do, it should use conditional rendering as much as possible to avoid CPU-GPU sync points) 2. GPU based skeletal animation (many engines still use CPU side skinning, despite the technology for GPU based animation is there for a decade now) 3. Instancing support (especially for particles, vegetation and other similar stuff) 4. Uniform buffer support (remove all glUniform* calls, despite they are still in core, allows also for batching) 5. Texture array support (use them as much as possible, batch draw commands together)

The most important take away here is to batch. GL 3.x+ provides dozens of different tech to support this, unfortunately they go unused 99% of the time.



CompilingEdit

WARP3DEdit

Recompiling a program that use Warp3D.library is quite simple. You just need to link it to Warp3D

So compiling cow3d for Aros x86 was as simple as gcc -c -O3 CoW3D-3.c -o Cow3D-Aros -lWarp3D

Wazp3D-Prefs is a little tool for selecting how Wazp3D works (fast or nice).

Aros version is included with Aminet/Cow3D (see Wazp3D homepage for documentation) Option "Renderer:Soft to Image" is safer if your Aros system dont support LockBitmapTags() else "Renderer:Soft to Bitmap" If your Aros support "Native Graphics Aros" then you can try "Renderer:hard overlay" or "Renderer:hard" but the display is not perfect as Mesa dont support rendering to bitmap as Warp3D


You need to use W3D_DrawTriFan(), W3D_DrawTriSttrip() or better still, W3D_DrawArray() with their corresponding data structures. Suggest the latter since you have much more control over how the vertex data is organised.

You create a triangle strip or a triangle fan. In a strip, alternate triangles share two points along an edge. In a fan, all triangles share one common vertex and adjacent triangles also share an edge. The simplest to illustrate is the strip. A rectangle is simply a 2 triangle strip, something like this:

V[0]--V[1]
|      /|
|     / |
|    /  |
|   /   |
|  /    |
V[2]--V[3]

Using one of the strip drawing methods, the same texture is applied to all polygons in the strip. If you use the old single triangle routines, you have to either enable global texture environment or specify the texture in each polygon separately.

Warp3D is a rasterizer only. That means that it draws primitives in screen space. Stictly, the axes are defined as X=left to right in pixels, Y top to botton in pixels, Z is plane of the screen into the distance. The valid range for Z is 0.0 - 1.0.

You need to calculate your vertices in screen space directly or write your own transformation pipeline.

See Starship3D


MESA 3DEdit

From client perspective using mesa.library is quite simple:

1) For programs that simply use OpenGL and Glut (like Aminet/starship) then just compile them

gcc starship.c -lglut -lgl - o starshiparos


2) For programs that use OpenGL and Amiga windowing system

  • Create a window
  • Call AROSMesaCreateContext passing it the window and some other stuff -> you get rendering context in return
  • Call AROSMesaMakeCurrent passing it the context so that AROSMesa knows what to render on
  • Render some stuff using glXXX functions
  • Call AROSMesaSwapBuffers to have the content of render buffer painted onto your window
  • Loop to glXXX functions

[...]

  • Call AROSMesaDestroyContext(context);
  • Call CloseWindow(window);


OpenGL API has been changed in ABI V1, just rename 'glA' to 'AROSMesa' The VBO functions are still there, but you need to access them via glaGetProcAddress.


#include <exec/types.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <intuition/screens.h>
#include <cybergraphx/cybergraphics.h>

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/intuition.h>

#include <proto/timer.h>
#include <devices/timer.h>
#include <proto/cybergraphics.h>

#define GL_GLEXT_PROTOTYPES
#include <GL/arosmesa.h>

#include <stdio.h>

AROSMesaContext     glcont=NULL;
double              angle = 0.0;
double              angle_inc = 0.0;
BOOL                finished = FALSE;
struct Window *     win = NULL;
struct Device *     TimerBase = NULL;
struct timerequest  timereq;
struct MsgPort      timeport;
struct Library *    CyberGfxBase = NULL;
BOOL                fullscreen = FALSE;
    
GLuint              fragmentShader = 0;
GLuint              vertexShader = 0;
GLuint              shaderProgram = 0;
GLint               angleLocation = 0;


const GLchar * fragmentShaderSource =
"uniform float angle;"
"void main()"
"{"
"   vec4 v = vec4(gl_Color);"
"   float intensity = abs(1.0f - (mod(angle, 1440.0f) / 720.0f));"
"   v.b = v.b * intensity;"
"   v.g = v.g * (1.0f - intensity);"
"	gl_FragColor = v;"
"}";

const GLchar * vertexShaderSource =
"void main()"
"{	"
"   gl_FrontColor = gl_Color;"
"	gl_Position = ftransform();"
"}";


#define RAND_COL 1.0f
#define DEGREES_PER_SECOND 180.0
#define USE_PERSPECTIVE 1

void prepare_shader_program()
{
#define BUFFER_LEN 2048
    char buffer[BUFFER_LEN] = {0};
    int len;

    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    glGetShaderInfoLog(fragmentShader, BUFFER_LEN, &len, buffer);
    printf("Fragment shader compile output: %s\n", buffer);
    
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    glGetShaderInfoLog(vertexShader, BUFFER_LEN, &len, buffer);
    printf("Vertex shader compile output: %s\n", buffer);

    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram); 
    glGetProgramInfoLog(shaderProgram, BUFFER_LEN, &len, buffer);
    printf("Shader program compile output: %s\n", buffer);

#undef BUFFER_LEN    
}

void cleanup_shader_program()
{
    glUseProgram(0);
    glDetachShader(shaderProgram, fragmentShader);
    glDetachShader(shaderProgram, vertexShader);
    glDeleteShader(fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteProgram(shaderProgram);
}

void render_face()
{
    glBegin(GL_QUADS);
        glColor4f(RAND_COL , 0.0, RAND_COL, 0.3);
        glVertex3f(-0.25, -0.25, 0.0);
        glColor4f(0, RAND_COL, RAND_COL, 0.3);
        glVertex3f(-0.25, 0.25, 0.0);
        glColor4f(0 , 0, 0, 0.3);
        glVertex3f(0.25, 0.25, 0.0);
        glColor4f(RAND_COL , RAND_COL, 0, 0.3);
        glVertex3f(0.25, -0.25, 0.0);
    glEnd();

}

void render_cube()
{
    glPushMatrix();
    glRotatef(0.0, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    render_face();
    glPopMatrix();


    glPushMatrix();
    glRotatef(90.0, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    render_face();
    glPopMatrix();

    glPushMatrix();
    glRotatef(180.0, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    render_face();
    glPopMatrix();

    glPushMatrix();
    glRotatef(270.0, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    render_face();
    glPopMatrix();

    glPushMatrix();
    glRotatef(90.0, 1.0, 0.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    render_face();
    glPopMatrix();

    glPushMatrix();
    glRotatef(-90.0, 1.0, 0.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    render_face();
    glPopMatrix();
}

void render_triangle()
{
    glBegin(GL_TRIANGLES);
        glColor4f(1.0, 0.0, 0.0, 1.0);
        glVertex3f(-0.25, -0.25, 0.0);
        glColor4f(0.0, 1.0, 0.0, 1.0);
        glVertex3f(-0.25,  0.25, 0.0);
        glColor4f(0.0, 0.0, 1.0, 1.0);
        glVertex3f( 0.25,  0.25, 0.0);
    glEnd();
}

void render()
{
    glLoadIdentity();
    glClearColor(0.3, 0.3, 0.3, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glCullFace(GL_BACK);
    glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
    glEnable(GL_BLEND);

    angle += angle_inc;
    glUniform1f(angleLocation, angle);

#if USE_PERSPECTIVE == 1
    glTranslatef(0.0, 0.0, -6.0);
#endif    
    glPushMatrix();
    glRotatef(angle, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, 0.25);
    glRotatef(angle, 1.0, 0.0, 1.0);
    render_cube();
    glPopMatrix();

    glDisable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);

    AROSMesaSwapBuffers(glcont);
}    

#define VISIBLE_WIDTH 300
#define VISIBLE_HEIGHT 300

void initmesa()
{
    struct TagItem attributes [ 14 ]; /* 14 should be more than enough :) */
    int i = 0;
    GLfloat h = 0.0f;
    
    attributes[i].ti_Tag = AMA_Window;      attributes[i++].ti_Data = (IPTR)win;
    attributes[i].ti_Tag = AMA_Left;        attributes[i++].ti_Data = win->BorderLeft;
    attributes[i].ti_Tag = AMA_Top;         attributes[i++].ti_Data = win->BorderTop;
    attributes[i].ti_Tag = AMA_Bottom;      attributes[i++].ti_Data = win->BorderBottom;
    attributes[i].ti_Tag = AMA_Right;       attributes[i++].ti_Data = win->BorderRight;

    // double buffer ?
    attributes[i].ti_Tag = AMA_DoubleBuf;   attributes[i++].ti_Data = GL_TRUE;

    // RGB(A) Mode ?
    attributes[i].ti_Tag = AMA_RGBMode;     attributes[i++].ti_Data = GL_TRUE;
    
    /* Stencil/Accum */
    attributes[i].ti_Tag = AMA_NoStencil;   attributes[i++].ti_Data = GL_TRUE;
    attributes[i].ti_Tag = AMA_NoAccum;     attributes[i++].ti_Data = GL_TRUE;
    
    // done...
    attributes[i].ti_Tag    = TAG_DONE;

    glcont = AROSMesaCreateContext(attributes);
    if (glcont)
    {
        AROSMesaMakeCurrent(glcont);
        h = (GLfloat)VISIBLE_HEIGHT / (GLfloat)VISIBLE_WIDTH ;

        glViewport(0, 0, (GLint) VISIBLE_WIDTH, (GLint) VISIBLE_HEIGHT);
#if USE_PERSPECTIVE == 1
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glFrustum(-1.0, 1.0, -h, h, 5.0, 200.0);
        glMatrixMode(GL_MODELVIEW);
#endif
        prepare_shader_program();
        glUseProgram(shaderProgram);
        angleLocation = glGetUniformLocation(shaderProgram, "angle");
    }
    else
        finished = TRUE; /* Failure. Stop */
}

void deinitmesa()
{
    if (glcont) 
    {
        cleanup_shader_program();
        AROSMesaDestroyContext(glcont);
    }
}

static int init_timerbase()
{
    timeport.mp_Node.ln_Type   = NT_MSGPORT;
    timeport.mp_Node.ln_Pri    = 0;
    timeport.mp_Node.ln_Name   = NULL;
    timeport.mp_Flags          = PA_IGNORE;
    timeport.mp_SigTask        = FindTask(NULL);
    timeport.mp_SigBit         = 0;
    NEWLIST(&timeport.mp_MsgList);

    timereq.tr_node.io_Message.mn_Node.ln_Type    = NT_MESSAGE;
    timereq.tr_node.io_Message.mn_Node.ln_Pri     = 0;
    timereq.tr_node.io_Message.mn_Node.ln_Name    = NULL;
    timereq.tr_node.io_Message.mn_ReplyPort       = &timeport;
    timereq.tr_node.io_Message.mn_Length          = sizeof (timereq);

    if(OpenDevice("timer.device",UNIT_VBLANK,(struct IORequest *)&timereq,0) == 0)
    {
        TimerBase = (struct Device *)timereq.tr_node.io_Device;
        return 1;
    }
    else
    {
        return 0;
    }
}


static void deinit_timerbase()
{
    if (TimerBase != NULL)
        CloseDevice((struct IORequest *)&timereq);
}


void HandleIntuiMessages(void)
{
    struct IntuiMessage *msg;

    while((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
    {
        switch(msg->Class)
        {
        case IDCMP_CLOSEWINDOW:
            finished = TRUE;
            break;
        case IDCMP_VANILLAKEY:
            if (msg->Code == 27 /* ESC */) finished = TRUE;
            break;
        }
        ReplyMsg((struct Message *)msg);
    }
}


#define ARG_FULLSCREEN  0
#define NUM_ARGS        1

STATIC CONST_STRPTR   TEMPLATE=(CONST_STRPTR) "FULLSCREEN/S";
static struct RDArgs  *myargs;
static IPTR           args[NUM_ARGS];

void get_arguments(void)
{
    if((myargs = ReadArgs(TEMPLATE, args, NULL)))
    {
        fullscreen = (BOOL)args[ARG_FULLSCREEN];
        FreeArgs(myargs);
    }
}

/*
** Open a simple window using OpenWindowTagList()
*/
int main(void)
{
    ULONG fps = 0;
//    ULONG exitcounter = 0;
    TEXT title[100];
    struct Screen * pubscreen = NULL;
    struct Screen * customscreen = NULL;
    LONG modeid;
    
    struct timeval tv;
    UQUAD lastmicrosecs = 0L;
    UQUAD currmicrosecs = 0L;
    UQUAD fpsmicrosecs = 0L;
    
    get_arguments();
    
    init_timerbase();
    
    GetSysTime(&tv);
    lastmicrosecs = tv.tv_secs * 1000000 + tv.tv_micro;
    fpsmicrosecs = lastmicrosecs;

    if (fullscreen)
    {
        CyberGfxBase = OpenLibrary("cybergraphics.library", 0L);
        
        modeid = BestCModeIDTags(CYBRBIDTG_NominalWidth, VISIBLE_WIDTH,
                                    CYBRBIDTG_NominalHeight, VISIBLE_HEIGHT,
                                    TAG_DONE);
        
        customscreen = OpenScreenTags(NULL,
                            SA_Type,        CUSTOMSCREEN,
                            SA_DisplayID,   modeid,
                            SA_Width,       VISIBLE_WIDTH,
                            SA_Height,      VISIBLE_HEIGHT,
                            SA_ShowTitle,   FALSE,
                            SA_Quiet,       TRUE,
                            TAG_DONE);

        win = OpenWindowTags(NULL,
                WA_Left,            0,
                WA_Top,             200,
                WA_InnerWidth,      VISIBLE_WIDTH,
                WA_InnerHeight,     VISIBLE_HEIGHT,
                WA_CustomScreen,    (IPTR)customscreen,
                WA_Flags,           WFLG_ACTIVATE | WFLG_BACKDROP | WFLG_BORDERLESS | WFLG_RMBTRAP,
                WA_IDCMP,           IDCMP_VANILLAKEY,
                TAG_DONE);
    }
    else
    {
        if ((pubscreen = LockPubScreen(NULL)) == NULL) return 1;
        
        win = OpenWindowTags(0,
                            WA_Title, (IPTR)"MesaSimpleRendering",
                            WA_PubScreen, pubscreen,
                            WA_CloseGadget, TRUE,
                            WA_DragBar, TRUE,
                            WA_DepthGadget, TRUE,
                            WA_Left, 50,
                            WA_Top, 200,
                            WA_InnerWidth, VISIBLE_WIDTH,
                            WA_InnerHeight, VISIBLE_HEIGHT,
                            WA_Activate, TRUE,
                            WA_RMBTrap, TRUE,
                            WA_SimpleRefresh, TRUE,
                            WA_NoCareRefresh, TRUE,
                            WA_IDCMP, IDCMP_VANILLAKEY | IDCMP_CLOSEWINDOW,
                            TAG_DONE);
        
        UnlockPubScreen(NULL, pubscreen);
    }
                   
    initmesa();
//    finished = TRUE;
    while(!finished)
    {
        GetSysTime(&tv);
        currmicrosecs = tv.tv_secs * 1000000 + tv.tv_micro;
        
        if (currmicrosecs - fpsmicrosecs > 1000000)
        {
            /* FPS counting is naive! */
            fpsmicrosecs += 1000000;
            sprintf(title, "MesaSimpleRendering, FPS: %d", fps);
            SetWindowTitles(win, title, (UBYTE *)~0L);
            fps = 0;
        }
        
        angle_inc = ((double)(currmicrosecs - lastmicrosecs) / 1000000.0) * DEGREES_PER_SECOND;
        lastmicrosecs = currmicrosecs;
        
        fps++; 
        render();
        HandleIntuiMessages();
//        exitcounter++;
//        Delay(10);
//        if (exitcounter > 0) finished = TRUE;
    }
    
    deinitmesa();
    
    deinit_timerbase();
      
    CloseWindow(win);
    
    if (customscreen) CloseScreen(customscreen);
    
    if (CyberGfxBase) CloseLibrary(CyberGfxBase);
    
    return 0;
}



/*
Copyright (C) 2006-2011 Mark Olsen

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <intuition/extensions.h>
#include <cybergraphx/cybergraphics.h>

#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/cybergraphics.h>

#include <GL/arosmesa.h>

#include "quakedef.h"
#include "input.h"
#include "keys.h"
#include "gl_local.h"
#include "in_morphos.h"
#include "vid_mode_morphos.h"

struct Library *MesaBase = 0;

struct display
{
	void *inputdata;

	unsigned int width, height;
	int fullscreen;
	char used_mode[256];

	struct Screen *screen;
	struct Window *window;

	void *pointermem;

	char pal[256*4];

	AROSMesaContext mesacontext;
};

void Sys_Video_CvarInit(void)
{
}

void *Sys_Video_Open(const char *mode, unsigned int width, unsigned int height, int fullscreen, unsigned char *palette)
{
	struct display *d;
	struct modeinfo modeinfo;
	char monitorname[128];
	int r;
	int i;

	d = AllocVec(sizeof(*d), MEMF_CLEAR);
	if (d)
	{
		MesaBase = OpenLibrary("mesa.library", 0);
		if (MesaBase)
		{
			if (fullscreen)
			{
				if (*mode && modeline_to_modeinfo(mode, &modeinfo))
				{
					snprintf(monitorname, sizeof(monitorname), "%s.monitor", modeinfo.monitorname);
					d->screen = OpenScreenTags(0,
						SA_Width, modeinfo.width,
						SA_Height, modeinfo.height,
						SA_Depth, modeinfo.depth,
#if 0
						SA_MonitorName, monitorname,
#endif
						SA_Quiet, TRUE,
						TAG_DONE);
				}
				else
				{
					d->screen = OpenScreenTags(0,
						SA_Quiet, TRUE,
						TAG_DONE);
				}

				if (d->screen)
				{
					width = d->screen->Width;
					height = d->screen->Height;

					snprintf(d->used_mode, sizeof(d->used_mode), "Dunno,%d,%d,42", width, height);
				}
				else
					fullscreen = 0;
			}

			if (d->screen || !fullscreen)
			{
				d->window = OpenWindowTags(0,
					d->screen?WA_Width:WA_InnerWidth, width,
					d->screen?WA_Height:WA_InnerHeight, height,
					WA_Title, "FodQuake",
					WA_DragBar, d->screen?FALSE:TRUE,
					WA_DepthGadget, d->screen?FALSE:TRUE,
					WA_Borderless, d->screen?TRUE:FALSE,
					WA_RMBTrap, TRUE,
					d->screen?WA_CustomScreen:TAG_IGNORE, (IPTR)d->screen,
					WA_Activate, TRUE,
					TAG_DONE);

				if (d->window)
				{
					d->mesacontext = AROSMesaCreateContextTags(
						AMA_Window, d->window,
						AMA_Left, d->screen?0:d->window->BorderLeft,
						AMA_Top, d->screen?0:d->window->BorderTop,
						AMA_Width, width,
						AMA_Height, height,
						AMA_NoStencil, TRUE,
						AMA_NoAccum, TRUE,
						TAG_DONE);

					if (d->mesacontext)
					{
						AROSMesaMakeCurrent(d->mesacontext);
						
						d->pointermem = AllocVec(256, MEMF_ANY|MEMF_CLEAR);
						if (d->pointermem)
						{
							SetPointer(d->window, d->pointermem, 16, 16, 0, 0);

							d->width = width;
							d->height = height;
							d->fullscreen = fullscreen;

							d->inputdata = Sys_Input_Init(d->screen, d->window);
							if (d->inputdata)
							{
								return d;
							}

							FreeVec(d->pointermem);
						}

						AROSMesaMakeCurrent(0);
						AROSMesaDestroyContext(d->mesacontext);
					}

					CloseWindow(d->window);
				}

				if (d->screen)
					CloseScreen(d->screen);
			}

			CloseLibrary(MesaBase);
		}

		FreeVec(d);
	}

	return 0;
}

void Sys_Video_Close(void *display)
{
	struct display *d = display;

	Sys_Input_Shutdown(d->inputdata);

	AROSMesaMakeCurrent(0);
	AROSMesaDestroyContext(d->mesacontext);

	CloseWindow(d->window);

	FreeVec(d->pointermem);

	if (d->screen)
		CloseScreen(d->screen);

	CloseLibrary(MesaBase);

	FreeVec(d);
}

unsigned int Sys_Video_GetNumBuffers(void *display)
{
	struct display *d;
	
	d = display;

	return d->screen ? 3 : 1;
}

int Sys_Video_GetKeyEvent(void *display, keynum_t *keynum, qboolean *down)
{
	struct display *d = display;

	return Sys_Input_GetKeyEvent(d->inputdata, keynum, down);
}
 
void Sys_Video_GetMouseMovement(void *display, int *mousex, int *mousey)
{
	struct display *d = display;

	Sys_Input_GetMouseMovement(d->inputdata, mousex, mousey);
}

void Sys_Video_SetWindowTitle(void *display, const char *text)
{
	struct display *d;

	d = display;

	SetWindowTitles(d->window, text, (void *)-1);
}

unsigned int Sys_Video_GetWidth(void *display)
{
	struct display *d;

	d = display;

	return d->width;
}

unsigned int Sys_Video_GetHeight(void *display)
{
	struct display *d;

	d = display;

	return d->height;
}

qboolean Sys_Video_GetFullscreen(void *display)
{
	struct display *d;

	d = display;

	return d->fullscreen;
}

const char *Sys_Video_GetMode(void *display)
{
	struct display *d;

	d = display;

	return d->used_mode;
}

void Sys_Video_BeginFrame(void *display, unsigned int *x, unsigned int *y, unsigned int *width, unsigned int *height)
{
	struct display *d;

	d = display;

	*x = 0;
	*y = 0;
	*width = d->width;
	*height = d->height;
}

void Sys_Video_Update(void *display, vrect_t *rects)
{
	struct display *d = display;

	AROSMesaSwapBuffers(d->mesacontext);
}

void Sys_Video_GrabMouse(void *display, int dograb)
{
	struct display *d = display;

	if (!d->screen)
	{
		Sys_Input_GrabMouse(d->inputdata, dograb);

		if (dograb)
		{
			/* Hide pointer */

			SetPointer(d->window, d->pointermem, 16, 16, 0, 0);
		}
		else
		{
			/* Show pointer */

			ClearPointer(d->window);
		}
	}
}

void Sys_Video_SetGamma(void *display, unsigned short *ramps)
{
}

qboolean Sys_Video_HWGammaSupported(void *display)
{
	return 0; 
}

int Sys_Video_FocusChanged(void *display)
{
	return 0;
}



ReferenceEdit

slowdown when running multiple 3d apps: this happens because of the GL semaphore "ping pong" between the tasks which can cause like >10000 task switches (and GL context switches) per second.

Semaphores are evil! It you have two or more tasks (3d apps) competing for sem then they get into ping pong state when a task is preempted while he owns the sem which is very likely. From then on (until a task switch happens while the sem is *not* locked) what will happen is that only one (GL) call can be made by task #1, then task switch to task #2 happens, which also can only make one (GL) call, then task switch to task #1 happens, which can only make one (GL) call, then task switch to task #2 happens, etc.

One solution to prevent this would be to have some GrabGL/UngrabGL (or ObtainGL,ReleaseGL if that sounds better) functions to be used in 3D apps and then enclose big parts of GL rendering function calls with it. GrabGL would lock the GL sem and make sure context is correct. ReleaseGL would unlock the GL sem. Even better would be if GrabGL switched all the GL functions (through function table) to versions which which don't use semlock/contextcheck/semunlock at all.


GL_VERSION: 1.4 Mesa 7.11
GL_EXTENSIONS: GL_ARB_multisample GL_EXT_abgr GL_EXT_bgra GL_EXT_blend_color GL_EXT_blend_logic_op GL_EXT_blend_minmax GL_EXT_blend_subtract GL_EXT_copy_texture GL_EXT_polygon_offset GL_EXT_subtexture GL_EXT_texture_object GL_EXT_vertex_array GL_EXT_compiled_vertex_array GL_EXT_texture GL_EXT_texture3D GL_IBM_rasterpos_clip GL_ARB_point_parameters GL_EXT_draw_range_elements GL_EXT_packed_pixels GL_EXT_point_parameters GL_EXT_rescale_normal GL_EXT_separate_specular_color GL_EXT_texture_edge_clamp GL_SGIS_generate_mipmap GL_SGIS_texture_border_clamp GL_SGIS_texture_edge_clamp GL_SGIS_texture_lod GL_ARB_multitexture GL_IBM_multimode_draw_arrays GL_IBM_texture_mirrored_repeat GL_ARB_texture_cube_map GL_ARB_texture_env_add GL_ARB_transpose_matrix GL_EXT_blend_func_separate GL_EXT_fog_coord GL_EXT_multi_draw_arrays GL_EXT_secondary_color GL_EXT_texture_env_add GL_EXT_texture_filter_anisotropic GL_EXT_texture_lod_bias GL_INGR_blend_func_separate GL_NV_blend_square GL_NV_light_max_exponent GL_NV_texgen_reflection GL_NV_texture_env_combine4 GL_SUN_multi_draw_arrays GL_ARB_texture_border_clamp GL_ARB_texture_compression GL_EXT_framebuffer_object GL_EXT_texture_env_dot3 GL_MESA_window_pos GL_NV_packed_depth_stencil GL_NV_texture_rectangle GL_ARB_depth_texture GL_ARB_shadow GL_ARB_texture_env_combine GL_ARB_texture_env_crossbar GL_ARB_texture_env_dot3 GL_ARB_texture_mirrored_repeat GL_ARB_window_pos GL_EXT_stencil_two_side GL_EXT_texture_cube_map GL_APPLE_packed_pixels GL_APPLE_vertex_array_object GL_ARB_draw_buffers GL_ARB_fragment_program GL_ARB_vertex_program GL_ATI_draw_buffers GL_ATI_texture_env_combine3 GL_EXT_shadow_funcs GL_EXT_stencil_wrap GL_MESA_pack_invert GL_MESA_ycbcr_texture GL_NV_primitive_restart GL_ARB_fragment_program_shadow GL_ARB_half_float_pixel GL_ARB_point_sprite GL_ARB_sync GL_ARB_texture_non_power_of_two GL_ARB_vertex_buffer_object GL_OES_read_format GL_ARB_color_buffer_float GL_ARB_pixel_buffer_object GL_ARB_texture_rectangle GL_EXT_pixel_buffer_object GL_EXT_texture_rectangle GL_ARB_framebuffer_object GL_EXT_framebuffer_blit GL_EXT_framebuffer_multisample GL_EXT_packed_depth_stencil GL_ARB_vertex_array_object GL_ATI_separate_stencil GL_EXT_gpu_program_parameters GL_EXT_texture_env_combine GL_OES_EGL_image GL_ARB_copy_buffer GL_ARB_map_buffer_range GL_ARB_vertex_array_bgra GL_EXT_vertex_array_bgra GL_ARB_draw_elements_base_vertex GL_ARB_fragment_coord_conventions GL_ARB_provoking_vertex GL_ARB_sampler_objects GL_EXT_provoking_vertex GL_ARB_robustness 
GL_RENDERER: Gallium 0.4 on i915 (chipset: 915GM)
GL_VENDOR: VMware, Inc.
GLU_VERSION: 1.3
GLU_EXTENSIONS: GLU_EXT_nurbs_tessellator GLU_EXT_object_space_tess 
GLUT_API_VERSION: 5
GLUT_XLIB_IMPLEMENTATION: 15