#else
- #if !defined(__ANDROID__)
+ #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
#define property _property
#define new _new
#undef String
#endif
-#if defined(__ANDROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
+
+#define uint _uint
+#define property _property
+#define new _new
+#define class _class
+#define Window X11Window
+#define Cursor X11Cursor
+#define Font X11Font
+#define Display X11Display
+#define Time X11Time
+#define KeyCode X11KeyCode
+#define Picture X11Picture
+#define Bool X11Bool
#include <GLES/gl.h>
#include <EGL/egl.h>
+#undef Bool
+#undef Picture
+#undef Window
+#undef Cursor
+#undef Font
+#undef Display
+#undef Time
+#undef KeyCode
+#undef uint
+#undef new
+#undef property
+#undef class
+
+#elif defined(__EMSCRIPTEN__)
+
+ #define property _property
+ #define uint _uint
+
+ #include <GL/gl.h>
+
+ //#include <GLES/gl.h>
+ //#include <EGL/egl.h>
+
+ //#include <GLES2/gl.h>
+ //#include <EGL/egl.h>
+
+ //#include <GLES2/gl2.h>
+ #include <GL/glfw.h>
+ #include <emscripten/emscripten.h>
+
+ #undef property
+ #undef uint
+
#else
#include <GL/gl.h>
#endif
+#if defined(__ODROID__) && !defined(_GLES)
+#define _GLES
+#endif
+
+#if defined(__EMSCRIPTEN__)
+#define EM_MODE
+// #define _GLES
+#endif
+
+//#define EM_MODE
+
#undef pointer
import "Display"
#if defined(__unix__) || defined(__APPLE__)
- #ifndef __ANDROID__
+ #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
import "XInterface"
#endif
static double nearPlane = 1;
+public double glesGetNearPlane()
+{
+ return nearPlane;
+}
+
+public void glesSetNearPlane(double value)
+{
+ nearPlane = value;
+}
+
#define glLoadMatrix glLoadMatrixd
#define glMultMatrix glMultMatrixd
#define glGetMatrix glGetDoublev
static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
+#elif defined(__ANDROID__) || defined(__ODROID__)
+
+ #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
+ #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
+ #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
+
+ #define GL_POLYGON_STIPPLE 0xFFFF
+ #define GL_LINE_STIPPLE 0xFFFF
+ #define GL_LINE 0xFFFF
+ #define GL_FILL 0xFFFF
+ #define GL_ALL_ATTRIB_BITS 0xFFFF
+ #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
+
+ #define GL_POLYGON 9
+ #define GL_QUADS 7
+
+ //#define GL_QUADS 0
+ #define GL_QUAD_STRIP 0
+ //#define GL_DOUBLE 0
+ //#define GL_UNSIGNED_INT 0
+ //#define GL_FILL 0
+ //#define GL_LINE 0
+ //#define GL_LINE_STIPPLE 0
+ #define GL_BGRA_EXT 0
+ #define GL_UNPACK_ROW_LENGTH 0
+ #define GL_UNPACK_SKIP_PIXELS 0
+ #define GL_UNPACK_SKIP_ROWS 0
+ #define GL_RGBA8 0
+ #define GL_PACK_ROW_LENGTH 0
+ #define GL_PACK_SKIP_ROWS 0
+ #define GL_PACK_SKIP_PIXELS 0
+
+#endif
+
+#if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
+public union Matrix
+{
+ double array[16];
+ double m[4][4];
+
+ void Identity()
+ {
+ FillBytesBy4(this, 0, sizeof(Matrix) >> 2);
+ m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
+ }
+
+ void Transpose(Matrix source)
+ {
+ int i,j;
+ for(i=0; i<4; i++)
+ for(j=0; j<4; j++)
+ m[j][i] = source.m[i][j];
+ }
+
+ void Multiply(Matrix a, Matrix b)
+ {
+ // We need a full matrix multiplication for the Projection matrix
+ m[0][0]=a.m[0][0]*b.m[0][0] + a.m[0][1]*b.m[1][0] + a.m[0][2]*b.m[2][0] + a.m[0][3]*b.m[3][0];
+ m[0][1]=a.m[0][0]*b.m[0][1] + a.m[0][1]*b.m[1][1] + a.m[0][2]*b.m[2][1] + a.m[0][3]*b.m[3][1];
+ m[0][2]=a.m[0][0]*b.m[0][2] + a.m[0][1]*b.m[1][2] + a.m[0][2]*b.m[2][2] + a.m[0][3]*b.m[3][2];
+ m[0][3]=a.m[0][0]*b.m[0][3] + a.m[0][1]*b.m[1][3] + a.m[0][2]*b.m[2][3] + a.m[0][3]*b.m[3][3];
+
+ m[1][0]=a.m[1][0]*b.m[0][0] + a.m[1][1]*b.m[1][0] + a.m[1][2]*b.m[2][0] + a.m[1][3]*b.m[3][0];
+ m[1][1]=a.m[1][0]*b.m[0][1] + a.m[1][1]*b.m[1][1] + a.m[1][2]*b.m[2][1] + a.m[1][3]*b.m[3][1];
+ m[1][2]=a.m[1][0]*b.m[0][2] + a.m[1][1]*b.m[1][2] + a.m[1][2]*b.m[2][2] + a.m[1][3]*b.m[3][2];
+ m[1][3]=a.m[1][0]*b.m[0][3] + a.m[1][1]*b.m[1][3] + a.m[1][2]*b.m[2][3] + a.m[1][3]*b.m[3][3];
+
+ m[2][0]=a.m[2][0]*b.m[0][0] + a.m[2][1]*b.m[1][0] + a.m[2][2]*b.m[2][0] + a.m[2][3]*b.m[3][0];
+ m[2][1]=a.m[2][0]*b.m[0][1] + a.m[2][1]*b.m[1][1] + a.m[2][2]*b.m[2][1] + a.m[2][3]*b.m[3][1];
+ m[2][2]=a.m[2][0]*b.m[0][2] + a.m[2][1]*b.m[1][2] + a.m[2][2]*b.m[2][2] + a.m[2][3]*b.m[3][2];
+ m[2][3]=a.m[2][0]*b.m[0][3] + a.m[2][1]*b.m[1][3] + a.m[2][2]*b.m[2][3] + a.m[2][3]*b.m[3][3];
+
+ m[3][0]=a.m[3][0]*b.m[0][0] + a.m[3][1]*b.m[1][0] + a.m[3][2]*b.m[2][0] + a.m[3][3]*b.m[3][0];
+ m[3][1]=a.m[3][0]*b.m[0][1] + a.m[3][1]*b.m[1][1] + a.m[3][2]*b.m[2][1] + a.m[3][3]*b.m[3][1];
+ m[3][2]=a.m[3][0]*b.m[0][2] + a.m[3][1]*b.m[1][2] + a.m[3][2]*b.m[2][2] + a.m[3][3]*b.m[3][2];
+ m[3][3]=a.m[3][0]*b.m[0][3] + a.m[3][1]*b.m[1][3] + a.m[3][2]*b.m[2][3] + a.m[3][3]*b.m[3][3];
+ }
+};
#endif
// Our own matrix stack
#if defined(_GLES)
// OpenGL ES Porting Kit
-#if defined(__ANDROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
#define glBindFramebuffer glBindFramebufferOES
#define glBindRenderbuffer glBindRenderbufferOES
- #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
- #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
#define glFramebufferTexture2D glFramebufferTexture2DOES
- #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
#define glGenFramebuffers glGenFramebuffersOES
#define glGenRenderbuffers glGenRenderbuffersOES
#define glDeleteFramebuffers glDeleteFramebuffersOES
#define glDeleteRenderbuffers glDeleteRenderbuffersOES
- #define GL_POLYGON_STIPPLE 0xFFFF
- #define GL_LINE_STIPPLE 0xFFFF
- #define GL_LINE 0xFFFF
- #define GL_FILL 0xFFFF
- #define GL_ALL_ATTRIB_BITS 0xFFFF
- #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
#define GL_INT 0x1404
#define GL_UNSIGNED_INT 0x1405
#define GL_DOUBLE 0x140A
- #define GL_POLYGON 9
- #define GL_QUADS 7
#define APIENTRY
#endif
#define glColor4fv glesColor4fv
#define glLineStipple glesLineStipple
#define glNormal3fv glesNormal3fv
+ #define glNormal3f glesNormal3f
#define glTexCoord2fv glesTexCoord2fv
#define glColorMaterial glesColorMaterial
#define glVertex3fv glesVertex3fv
#define glLightModeli glesLightModeli
-#if defined(__ANDROID__)
- //#define GL_QUADS 0
- #define GL_QUAD_STRIP 0
- //#define GL_DOUBLE 0
- //#define GL_UNSIGNED_INT 0
- //#define GL_FILL 0
- //#define GL_LINE 0
- //#define GL_LINE_STIPPLE 0
- #define GL_BGRA_EXT 0
- #define GL_UNPACK_ROW_LENGTH 0
- #define GL_UNPACK_SKIP_PIXELS 0
- #define GL_UNPACK_SKIP_ROWS 0
- #define GL_RGBA8 0
- #define GL_PACK_ROW_LENGTH 0
- #define GL_PACK_SKIP_ROWS 0
- #define GL_PACK_SKIP_PIXELS 0
-#endif
-
#else
#define glVertexPointerd(nc, s, p, nv) glVertexPointer(nc, GL_DOUBLE, s, p)
#endif
-#if defined(__ANDROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
static EGLDisplay eglDisplay;
static EGLSurface eglSurface;
static EGLContext eglContext;
static int eglWidth, eglHeight;
+#if defined(__ANDROID__)
static bool egl_init_display(ANativeWindow* window)
+#else
+ static bool egl_init_display(uint window)
+#endif
{
const EGLint attribs[] =
{
glesLoadIdentity();
glOrtho(0,w,h,0,0.0,1.0);
- currentVertexBuffer = 0;
+ curArrayBuffer = 0;
+ curElementBuffer = 0;
return true;
}
static int normalCount;
static float *vertexPointer;
static float *normalPointer;
-static GLenum beginMode;
-static unsigned int beginBufferSize, normalBufferSize;
+static GLenum beginMode = -1;
+static uint beginBufferSize, normalBufferSize;
static int numVertexCoords = 2;
+static bool vertexColorValues = false;
+static int vertexStride = 4;
+static int vertexOffset = 2;
public void glesRecti(int a, int b, int c, int d)
{
beginMode = mode;
beginCount = 0;
vertexCount = 0;
+ vertexColorValues = false;
+ vertexOffset = 2;
+ vertexStride = 4;
+ numVertexCoords = 2;
+
if(!vertexPointer)
{
normalBufferSize = beginBufferSize = 1024; // default number of vertices
- vertexPointer = new float[beginBufferSize * 5];
+ vertexPointer = new float[beginBufferSize * vertexStride];
normalPointer = new float[normalBufferSize * 3];
}
}
if(vertexCount + numVertexCoords > beginBufferSize)
{
beginBufferSize = beginBufferSize + beginBufferSize/2;
- vertexPointer = renew vertexPointer float[beginBufferSize * 5];
+ vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
}
- vertexPointer[count*(2+numVertexCoords) ] = x;
- vertexPointer[count*(2+numVertexCoords)+1] = y;
+ vertexPointer[count*vertexStride ] = x;
+ vertexPointer[count*vertexStride+1] = y;
count++;
if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
{
- vertexPointer[count*(2+numVertexCoords) ] = vertexPointer[(count-4)*(2+numVertexCoords)];
- vertexPointer[count*(2+numVertexCoords)+1] = vertexPointer[(count-4)*(2+numVertexCoords)+1];
+ vertexPointer[count*vertexStride ] = vertexPointer[(count-4)*vertexStride];
+ vertexPointer[count*vertexStride+1] = vertexPointer[(count-4)*vertexStride+1];
count++;
- vertexPointer[count*(2+numVertexCoords) ] = vertexPointer[(count-3)*(2+numVertexCoords)];
- vertexPointer[count*(2+numVertexCoords)+1] = vertexPointer[(count-3)*(2+numVertexCoords)+1];
+ vertexPointer[count*vertexStride ] = vertexPointer[(count-3)*vertexStride];
+ vertexPointer[count*vertexStride+1] = vertexPointer[(count-3)*vertexStride+1];
count++;
}
}
public void glesVertex2f(float x, float y)
{
numVertexCoords = 2;
+ vertexStride = vertexOffset + numVertexCoords;
+
if(vertexCount + 4 > beginBufferSize)
{
beginBufferSize = beginBufferSize + beginBufferSize/2;
- vertexPointer = renew vertexPointer float[beginBufferSize * 5];
+ vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
}
- vertexPointer[vertexCount*4+2] = x;
- vertexPointer[vertexCount*4+3] = y;
+ vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
+ vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = y;
vertexCount++;
if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
{
- vertexPointer[vertexCount*4+2] = vertexPointer[(vertexCount-4)*4+2];
- vertexPointer[vertexCount*4+3] = vertexPointer[(vertexCount-4)*4+3];
+ vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
+ vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset + 1];
vertexCount++;
- vertexPointer[vertexCount*4+2] = vertexPointer[(vertexCount-3)*4+2];
- vertexPointer[vertexCount*4+3] = vertexPointer[(vertexCount-3)*4+3];
+ vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
+ vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset + 1];
vertexCount++;
}
beginCount++;
int mode = beginMode;
if(mode == GL_QUADS) mode = GL_TRIANGLES;
else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
- GLSelectVBO(0);
+
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- glTexCoordPointer(numVertexCoords, GL_FLOAT, (numVertexCoords+2)*sizeof(float),vertexPointer);
- glVertexPointer (numVertexCoords, GL_FLOAT, (numVertexCoords+2)*sizeof(float),vertexPointer+2);
+ noAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
+ if(vertexColorValues)
+ {
+ glEnableClientState(GL_COLOR_ARRAY);
+ noAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
+ }
+ noAB.use(vertex, numVertexCoords, GL_FLOAT, (vertexStride)*sizeof(float),vertexPointer+vertexOffset);
if(normalCount && normalCount == vertexCount)
{
glEnableClientState(GL_NORMAL_ARRAY);
- glNormalPointer (GL_FLOAT, 3*sizeof(float),normalPointer);
+ noAB.use(normal, 3, GL_FLOAT, 3*sizeof(float),normalPointer);
}
glDrawArrays(mode, 0, vertexCount);
if(normalCount)
glDisableClientState(GL_NORMAL_ARRAY);
+ if(vertexColorValues)
+ glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
normalCount = 0;
+ vertexColorValues = false;
+ numVertexCoords = 2;
+ beginMode = -1;
}
// Vertex Pointer
glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
}
+public void glesColor4f(float r, float g, float b, float a)
+{
+ if(beginMode != (GLenum)-1)
+ {
+ int count = vertexCount;
+
+ vertexColorValues = true;
+ vertexOffset = 6;
+ vertexStride = vertexOffset + numVertexCoords;
+
+ if(vertexCount + vertexStride > beginBufferSize)
+ {
+ beginBufferSize = beginBufferSize + beginBufferSize/2;
+ vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
+ }
+
+ vertexPointer[count*vertexStride + 2] = r;
+ vertexPointer[count*vertexStride + 3] = g;
+ vertexPointer[count*vertexStride + 4] = b;
+ vertexPointer[count*vertexStride + 5] = a;
+ count++;
+
+ if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
+ {
+ vertexPointer[count*vertexStride + 2] = vertexPointer[(count-4) * vertexStride + 2];
+ vertexPointer[count*vertexStride + 3] = vertexPointer[(count-4) * vertexStride + 3];
+ vertexPointer[count*vertexStride + 4] = vertexPointer[(count-4) * vertexStride + 4];
+ vertexPointer[count*vertexStride + 5] = vertexPointer[(count-4) * vertexStride + 5];
+ count++;
+ vertexPointer[count*vertexStride + 2] = vertexPointer[(count-3) * vertexStride + 2];
+ vertexPointer[count*vertexStride + 3] = vertexPointer[(count-3) * vertexStride + 3];
+ vertexPointer[count*vertexStride + 4] = vertexPointer[(count-3) * vertexStride + 4];
+ vertexPointer[count*vertexStride + 5] = vertexPointer[(count-3) * vertexStride + 5];
+ count++;
+ }
+ }
+ else
+ glColor4f(r, g, b, a);
+}
+
public void glesColor3f( float r, float g, float b )
{
- glColor4f(r, g, b, 1.0f);
+ glesColor4f(r, g, b, 1.0f);
}
public void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
- glColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
+ glesColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
}
public void glesColor4fv(float * a)
{
- glColor4f(a[0], a[1], a[2], a[3]);
+ glesColor4f(a[0], a[1], a[2], a[3]);
}
public void glesBufferDatad(int target, int size, void * data, int usage)
}
}
+#if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
public void glesRotated( double a, double b, double c, double d )
{
Quaternion q;
matrixStack[curStack][matrixIndex[curStack]] = r;
LoadCurMatrix();
}
+#endif
public void glesMatrixMode(int mode)
{
public void glesVertex3f( float x, float y, float z )
{
numVertexCoords = 3;
- if(vertexCount + 4 > beginBufferSize)
+ vertexStride = vertexOffset + numVertexCoords;
+
+ if(vertexCount + vertexStride > beginBufferSize)
{
beginBufferSize = beginBufferSize + beginBufferSize/2;
- vertexPointer = renew vertexPointer float[beginBufferSize * 5];
+ vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
}
- vertexPointer[vertexCount*5+2] = x;
- vertexPointer[vertexCount*5+3] = y;
- vertexPointer[vertexCount*5+4] = z;
+ vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
+ vertexPointer[vertexCount*vertexStride+vertexOffset+1] = y;
+ vertexPointer[vertexCount*vertexStride+vertexOffset+2] = z;
vertexCount++;
if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
{
- vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-4)*5+2];
- vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-4)*5+3];
- vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-4)*5+4];
+ vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
+ vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+1];
+ vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+2];
vertexCount++;
- vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-3)*5+2];
- vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-3)*5+3];
- vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-3)*5+4];
+ vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
+ vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+1];
+ vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+2];
vertexCount++;
}
beginCount++;
}
static GLuint stippleTexture;
-#if defined(_GLES)
+#if defined(_GLES) || defined(EM_MODE)
static bool stippleEnabled;
#endif
public void glesLightModeli( unsigned int pname, int param )
{
+#if !defined(EM_MODE)
if(pname == GL_LIGHT_MODEL_TWO_SIDE)
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
+#endif
}
-#ifdef __ANDROID__
+#if defined(__ANDROID__) || defined(__ODROID__)
void glClearDepth( double depth ) { glClearDepthf((float)depth); }
void glFogi( unsigned int pname, int param ) { }
void glPolygonMode( unsigned int i, unsigned int j ) { }
#endif
-#if !defined(__APPLE__) && !defined(__WIN32__)
+#if !defined(__APPLE__) && !defined(__WIN32__) && !defined(__ODROID__)
void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
#endif
-static int currentVertexBuffer;
+public void GLLoadMatrix(Matrix matrix)
+{
+ float m[16] =
+ {
+ (float)matrix.m[0][0], (float)matrix.m[0][1], (float)matrix.m[0][2], (float)matrix.m[0][3],
+ (float)matrix.m[1][0], (float)matrix.m[1][1], (float)matrix.m[1][2], (float)matrix.m[1][3],
+ (float)matrix.m[2][0], (float)matrix.m[2][1], (float)matrix.m[2][2], (float)matrix.m[2][3],
+ (float)matrix.m[3][0], (float)matrix.m[3][1], (float)matrix.m[3][2], (float)matrix.m[3][3]
+ };
+ glLoadMatrixf(m);
+}
+
+public enum GLBufferContents { vertex, normal, texCoord, color };
+
+public define noAB = GLAB { 0 };
+
+static uint curArrayBuffer;
+
+public struct GLAB
+{
+ uint buffer;
+
+ void upload(uint size, void * data)
+ {
+ if(this != null)
+ {
+ if(!buffer)
+ GLGenBuffers(1, this);
+ if(curArrayBuffer != buffer)
+ GLBindBuffer(GL_ARRAY_BUFFER, buffer);
+ glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
+ }
+ }
+
+ void free()
+ {
+ if(this != null)
+ {
+ GLDeleteBuffers(1, this);
+ buffer = 0;
+ }
+ }
+
+ void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
+ {
+ if(curArrayBuffer != ((this != null) ? buffer : 0))
+ GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
+ switch(contents)
+ {
+ case normal: glNormalPointer(type, stride, pointer); break;
+ case vertex: glVertexPointer(n, type, stride, pointer); break;
+ case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
+ case color: glColorPointer(n, type, stride, pointer); break;
+ }
+ }
+
+ void useVertTrans(uint count, int n, int type, uint stride, void * pointer)
+ {
+#ifdef _GLES
+ if(curArrayBuffer != ((this != null) ? buffer : 0))
+ GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
+ if(type == GL_INT)
+ glVertexPointeri(n, stride, pointer, count);
+ else if(type == GL_DOUBLE)
+ glVertexPointerd(n, stride, pointer, count);
+#else
+ use(vertex, n, type, stride, pointer);
+#endif
+ }
+};
+
+static uint curElementBuffer;
+
+public define noEAB = GLEAB { 0 };
-bool GLSelectVBO(uint vbo)
+public struct GLEAB
{
- if(currentVertexBuffer != vbo)
+ uint buffer;
+
+ void upload(uint size, void * data)
{
- GLBindBuffer(GL_ARRAY_BUFFER, vbo);
- currentVertexBuffer = vbo;
- return true;
+ if(this != null)
+ {
+ if(!buffer)
+ GLGenBuffers(1, (GLAB *)this);
+
+ if(curElementBuffer != buffer)
+ GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
+ }
}
- return false;
-}
-void GLGenBuffers(int count, uint * buffer)
+ void free()
+ {
+ if(this != null)
+ {
+ GLDeleteBuffers(1, (GLAB *)this);
+ buffer = 0;
+ }
+ }
+
+ void draw(int primType, int count, int type, void * indices)
+ {
+ if(curElementBuffer != ((this != null) ? buffer : 0))
+ GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
+#ifdef _GLES
+ type = GL_UNSIGNED_SHORT;
+#endif
+ glDrawElements(primType, count, type, indices);
+ }
+};
+
+public void GLGenBuffers(int count, GLAB * buffers)
{
-#ifdef __ANDROID__
- glGenBuffers(count, buffer);
+#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+ glGenBuffers(count, (GLuint *)buffers);
#else
#if defined(__WIN32__)
if(glGenBuffersARB)
#endif
- glGenBuffersARB(count, buffer);
+ glGenBuffersARB(count, (GLuint *)buffers);
#endif
}
-void GLDeleteBuffers(int count, GLuint * buffer)
+public void GLDeleteBuffers(int count, GLAB * buffers)
{
-#ifdef __ANDROID__
- glDeleteBuffers(count, buffer);
+ int i;
+ for(i = 0; i < count; i++)
+ {
+ uint buffer = buffers[i].buffer;
+ if(buffer == curArrayBuffer)
+ GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
+ else if(buffer == curElementBuffer)
+ GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
+ }
+#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+ glDeleteBuffers(count, (GLuint *)buffers);
#else
#if defined(__WIN32__)
if(glDeleteBuffersARB)
#endif
- glDeleteBuffersARB(count, buffer);
+ glDeleteBuffersARB(count, (GLuint *)buffers);
#endif
}
void GLBindBuffer(int target, uint buffer)
{
-#ifdef __ANDROID__
+#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
glBindBuffer(target, buffer);
#else
#if defined(__WIN32__)
#endif
glBindBufferARB(target, buffer);
#endif
+ if(target == GL_ARRAY_BUFFER_ARB)
+ curArrayBuffer = buffer;
+ else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
+ curElementBuffer = buffer;
}
public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
else
#endif
-#ifdef __ANDROID__
+#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
glBufferData(target, size, data, usage);
#else
int imageBuffers[2];
byte * pboMemory1, * pboMemory2;
*/
-#elif !defined(__ANDROID__)
+#elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
GLXContext glContext;
Pixmap pixmap;
HDC hdc;
HGLRC glrc;
HWND hwnd;
-#elif !defined(__ANDROID__)
+#elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
XVisualInfo * visualInfo;
GLXContext glContext;
GLXDrawable glxDrawable;
class OGLMesh : struct
{
- uint vertices;
- uint normals;
- uint texCoords;
- uint texCoords2;
- uint colors;
+ GLAB vertices;
+ GLAB normals;
+ GLAB texCoords;
+ GLAB texCoords2;
+ GLAB colors;
};
class OGLIndices : struct
{
uint16 * indices;
- uint buffer;
+ GLEAB buffer;
uint nIndices;
};
bool LockSystem(DisplaySystem displaySystem)
{
-#if !defined(__ANDROID__)
+#if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
OGLSystem oglSystem = displaySystem.driverData;
if(useSingleGLContext) return true;
#if defined(__WIN32__)
wglMakeCurrent(null, null);
#elif defined(__unix__) || defined(__APPLE__)
// printf("Making NULL current\n");
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
#else
glXMakeCurrent(xGlobalDisplay, None, null);
#endif
bool Lock(Display display)
{
-#if !defined(__ANDROID__)
+#if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
OGLDisplay oglDisplay = display.driverData;
if(useSingleGLContext) return true;
#if defined(__WIN32__)
if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
#else
if(oglDisplay.shapePixmap)
XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
vboAvailable = true;
#if defined(__ANDROID__)
egl_init_display(guiApp.desktop.windowHandle);
+ #elif defined(__ODROID__)
+ egl_init_display((uint)displaySystem.window);
CheckExtensions(oglSystem);
result = true;
+ #elif defined(__EMSCRIPTEN__)
+ if(glfwInit() == GL_TRUE)
+ {
+ const int width = 640, height = 480;
+ if(glfwOpenWindow(width, height, 8, 8, 8, 8, 16, 0, GLFW_WINDOW) == GL_TRUE)
+ {
+ //glfwSwapBuffers();
+ result = true;
+ }
+ else
+ printf("glfwOpenWindow() failed\n"); //glfwTerminate();
+ }
+ else
+ printf("glfwInit() failed\n"); //glfwTerminate();
#else
{
X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
DestroyWindow(oglSystem.hwnd);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__ODROID__)
egl_term_display();
+ #elif defined(__EMSCRIPTEN__)
+ glfwTerminate();
#else
if(oglSystem.visualInfo)
{
{
bool result = false;
OGLDisplay oglDisplay = display.driverData;
-#if !defined(__ANDROID__)
+#if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
OGLSystem oglSystem = display.displaySystem.driverData;
#endif
if(!oglDisplay)
else
ReleaseDC(display.window, oglDisplay.hdc);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
#else
XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
/*
glEnable(GL_BLEND);
glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity(); // For setting up GLES stack
glScaled(1.0, 1.0, -1.0);
// glTranslatef(0.375f, 0.375f, 0.0f);
// glTranslatef(-0.625f, -0.625f, 0.0f);
glShadeModel(GL_FLAT);
// glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
+#if !defined(EM_MODE)
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
+#endif
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0);
glEnable(GL_NORMALIZE);
#if defined(__WIN32__)
wglMakeCurrent(null, null);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
result = true;
#else
glXMakeCurrent(xGlobalDisplay, None, null);
#endif
#endif
}
+ else
+ {
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+ result = true;
+ #endif
+ }
return result;
}
ReleaseDC(display.window, hdc);
}
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
result = true;
#else
int attrib[] =
#if defined(__WIN32__)
wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
width = eglWidth;
height = eglHeight;
#else
result = false;
glViewport(0,0,width,height);
+ glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,width,height,0,0.0,1.0);
displayWidth = display.width = width;
ReleaseDC(0, hdc);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
#else
XTransform transform =
{
//wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
SwapBuffers(oglDisplay.hdc);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__)
+ #if defined(__ANDROID__) || defined(__ODROID__)
eglSwapBuffers(eglDisplay, eglSurface);
+ #elif defined(__EMSCRIPTEN__)
+ glfwSwapBuffers();
#else
glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
#endif
glBindTexture(GL_TEXTURE_2D, glBitmap);
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0 );
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
result = true;
- for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
+ for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
{
Bitmap mipMap;
+ if(!w) w = 1;
+ if(!h) h = 1;
if(bitmap.width != w || bitmap.height != h)
{
mipMap = Bitmap { };
convBitmap.driver.FreeBitmap(convBitmap.displaySystem, convBitmap);
bitmap.driverData = (void *)(uintptr)glBitmap;
bitmap.driver = displaySystem.driver;
+ if(bitmap.keepData)
+ delete convBitmap;
if(!result)
FreeBitmap(displaySystem, bitmap);
glColor4fv(oglSurface.foreground);
glBegin(GL_LINES);
-#ifdef _GLES
+#if defined(_GLES) || defined(EM_MODE)
if(stippleEnabled)
{
glTexCoord2f(0.5f, 0);
//Logf("Rectangle\n");
glColor4fv(oglSurface.foreground);
-#ifdef _GLES
+#if defined(_GLES) || defined(EM_MODE)
if(stippleEnabled)
{
glBegin(GL_LINES);
//Logf("Area\n");
glColor4fv(oglSurface.background);
+
+#ifdef EM_MODE
+ glBegin(GL_QUADS);
+ glVertex2f(x1+surface.offset.x, y1+surface.offset.y);
+ glVertex2f(x1+surface.offset.x, y2+surface.offset.y+1);
+ glVertex2f(x2+surface.offset.x+1, y2+surface.offset.y+1);
+ glVertex2f(x2+surface.offset.x+1, y1+surface.offset.y);
+ glEnd();
+#else
glRecti(x1+surface.offset.x, y1+surface.offset.y,
x2+surface.offset.x + 1, y2+surface.offset.y + 1);
-
+#endif
/*
glRectf(x1+surface.offset.x, y1+surface.offset.y,
x2+surface.offset.x + 1, y2+surface.offset.y + 1);
void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
{
+#if !defined(EM_MODE)
float s2dw,s2dh,d2sw,d2sh;
//bool flipX = false, flipY = false;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
}
+#endif
}
void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
{
+#if !defined(EM_MODE)
//Logf("BlitDI\n");
//Clip against the edges of the source
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
}
+#endif
}
void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
if(stipple)
{
-#if defined(_GLES)
+#if defined(_GLES) || defined(EM_MODE)
stippleEnabled = true;
glesLineStipple(1, (uint16)stipple);
#else
}
else
{
-#if defined(_GLES)
+#if defined(_GLES) || defined(EM_MODE)
stippleEnabled = false;
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
break;
case ambient:
{
+#if !defined(EM_MODE)
float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
+#endif
break;
}
case alphaWrite:
void SetLight(Display display, int id, Light light)
{
+#if !defined(EM_MODE)
//Logf("SetLight\n");
if(light != null)
}
else
glDisable(GL_LIGHT0 + id);
+#endif
}
void SetCamera(Display display, Surface surface, Camera camera)
glViewport(x, y, w, h);
// *** Projection Matrix ***
+ glMatrixMode(GL_PROJECTION);
if(!display.display3D.camera)
glPushMatrix();
- else
- glMatrixMode(GL_PROJECTION);
+
if(display.display3D.collectingHits)
{
float pickX = display.display3D.pickX + surface.offset.x;
// ...
glEnable(GL_DEPTH_TEST);
+//#if !defined(EM_MODE)
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
+//#endif
glDepthMask((byte)bool::true);
oglDisplay.depthWrite = true;
glDisable(GL_LIGHTING);
glDisable(GL_FOG);
glDisable(GL_TEXTURE_2D);
+//#if !defined(EM_MODE)
glShadeModel(GL_FLAT);
+//#endif
glEnable(GL_BLEND);
glDisable(GL_MULTISAMPLE_ARB);
glPopMatrix();
}
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
}
void ApplyMaterial(Display display, Material material, Mesh mesh)
// Basic Properties
if(material.flags.doubleSided)
{
+#if !defined(EM_MODE)
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
+#endif
glDisable(GL_CULL_FACE);
}
else
{
+#if !defined(EM_MODE)
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
+#endif
glEnable(GL_CULL_FACE);
}
else
glDisable(GL_TEXTURE_2D);
+#ifdef EM_MODE
+ glColor4f(material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity);
+#else
if(mesh.flags.colors)
{
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
}
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
+#endif
}
void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
{
if(!mesh.flags.vertices)
{
- if(oglMesh.vertices)
- {
- GLDeleteBuffers(1, &oglMesh.vertices);
- oglMesh.vertices = 0;
- }
+ oglMesh.vertices.free();
delete mesh.vertices;
}
if(!mesh.flags.normals)
{
- if(oglMesh.normals)
- {
- GLDeleteBuffers(1, &oglMesh.normals);
- oglMesh.normals = 0;
- }
+ oglMesh.normals.free();
delete mesh.normals;
}
if(!mesh.flags.texCoords1)
{
- if(oglMesh.texCoords)
- {
- GLDeleteBuffers(1, &oglMesh.texCoords);
- oglMesh.texCoords = 0;
- }
+ oglMesh.texCoords.free();
delete mesh.texCoords;
}
if(!mesh.flags.texCoords2)
{
- if(oglMesh.texCoords2)
- {
- GLDeleteBuffers(1, &oglMesh.texCoords2);
- oglMesh.texCoords2 = 0;
- }
- /*
- delete mesh.texCoords2;
- */
+ oglMesh.texCoords2.free();
+ // delete mesh.texCoords2;
}
if(!mesh.flags.colors)
{
- if(oglMesh.colors)
- {
- GLDeleteBuffers(1, &oglMesh.colors);
- oglMesh.colors = 0;
- }
+ oglMesh.colors.free();
+ delete mesh.colors;
}
if(!mesh.flags)
{
mesh.data = OGLMesh { };
if(mesh.data)
{
- OGLMesh oglMesh = mesh.data;
if(mesh.nVertices == nVertices)
{
// Same number of vertices, adding features (Leaves the other features pointers alone)
}
else
mesh.vertices = new Vector3Df[nVertices];
- if(!oglMesh.vertices)
- GLGenBuffers(1, &oglMesh.vertices);
}
if(!mesh.flags.normals && flags.normals)
{
}
else
mesh.normals = new Vector3Df[nVertices];
- if(!oglMesh.normals)
- GLGenBuffers( 1, &oglMesh.normals);
}
if(!mesh.flags.texCoords1 && flags.texCoords1)
{
mesh.texCoords = new Pointf[nVertices];
- if(!oglMesh.texCoords)
- GLGenBuffers( 1, &oglMesh.texCoords);
}
if(!mesh.flags.colors && flags.colors)
{
mesh.colors = new ColorRGBAf[nVertices];
- if(!oglMesh.colors)
- GLGenBuffers( 1, &oglMesh.colors);
}
}
}
}
else
mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
- if(!oglMesh.vertices)
- GLGenBuffers(1, &oglMesh.vertices);
}
if(flags.normals)
{
}
else
mesh.normals = renew mesh.normals Vector3Df[nVertices];
- if(!oglMesh.normals)
- GLGenBuffers( 1, &oglMesh.normals);
}
if(flags.texCoords1)
{
mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
- if(!oglMesh.texCoords)
- GLGenBuffers( 1, &oglMesh.texCoords);
}
if(flags.colors)
{
mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
- if(!oglMesh.colors)
- GLGenBuffers( 1, &oglMesh.colors);
}
}
result = true;
if(vboAvailable)
{
- if(flags.vertices && oglMesh.vertices)
- {
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices);
- GLBufferData( mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices, GL_STATIC_DRAW_ARB );
- }
+ if(flags.vertices)
+ oglMesh.vertices.upload(
+ mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
- if(flags.normals && oglMesh.normals)
- {
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
- GLBufferData( mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals, GL_STATIC_DRAW_ARB );
- }
+ if(flags.normals)
+ oglMesh.normals.upload(
+ mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
- if(flags.texCoords1 && oglMesh.texCoords)
- {
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
- GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(Pointf), mesh.texCoords, GL_STATIC_DRAW_ARB );
- }
+ if(flags.texCoords1)
+ oglMesh.texCoords.upload(
+ mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
- if(flags.colors && oglMesh.colors)
- {
- GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
- GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(ColorRGBAf), mesh.colors, GL_STATIC_DRAW_ARB );
- }
-
- GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
+ if(flags.colors)
+ oglMesh.colors.upload(
+ mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
}
}
{
if(oglIndices)
{
- if(oglIndices.buffer)
- GLDeleteBuffers(1, &oglIndices.buffer);
+ oglIndices.buffer.free();
delete oglIndices.indices;
delete oglIndices;
}
if(oglIndices)
{
oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
- GLGenBuffers( 1, &oglIndices.buffer);
oglIndices.nIndices = nIndices;
}
return oglIndices;
{
if(vboAvailable)
{
- GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
- GLBufferData( indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, GL_ELEMENT_ARRAY_BUFFER_ARB, nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
- oglIndices.indices, GL_STATIC_DRAW_ARB);
- GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
+#ifdef _GLES
+ if(indices32bit)
+ {
+ if(!oglIndices.buffer.buffer)
+ GLGenBuffers(1, (GLAB *)&oglIndices.buffer);
+ if(curElementBuffer != oglIndices.buffer.buffer)
+ GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, oglIndices.buffer.buffer);
+ glesBufferDatai(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * nIndices, oglIndices.indices, GL_STATIC_DRAW_ARB);
+ }
+ else
+#endif
+ oglIndices.buffer.upload(
+ nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
+ oglIndices.indices); //GL_STATIC_DRAW_ARB);
}
}
{
//Logf("SelectMesh\n");
-#if !defined( __ANDROID__) && !defined(__APPLE__)
+#if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
#if defined(__WIN32__)
if(glUnlockArraysEXT)
glEnableClientState(GL_VERTEX_ARRAY);
if(!display.display3D.collectingHits && oglMesh)
{
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices );
- if(mesh.flags.doubleVertices)
- glVertexPointerd(3, 0, (double *)(vboAvailable ? null : mesh.vertices), mesh.nVertices);
- else
- glVertexPointer(3, GL_FLOAT, 0, vboAvailable ? null : mesh.vertices);
+ oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
// *** Normals Stream ***
if(mesh.normals || mesh.flags.normals)
{
glEnableClientState(GL_NORMAL_ARRAY);
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
- glNormalPointer(/*mesh.flags.doubleNormals ? GL_DOUBLE : */GL_FLOAT, 0, vboAvailable ? null : mesh.normals);
+ oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
}
else
glDisableClientState(GL_NORMAL_ARRAY);
if(mesh.texCoords || mesh.flags.texCoords1)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
- glTexCoordPointer(2, GL_FLOAT, 0, vboAvailable ? null : mesh.texCoords);
+ oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
}
else
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if(mesh.colors || mesh.flags.colors)
{
glEnableClientState(GL_COLOR_ARRAY);
- GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
- glColorPointer(4, GL_FLOAT, 0, vboAvailable ? null : mesh.colors);
+ oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
}
else
glDisableClientState(GL_COLOR_ARRAY);
-
}
else
{
- GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
- if(mesh.flags.doubleVertices)
- glVertexPointerd(3, 0, (double *)mesh.vertices, mesh.nVertices);
- else
- glVertexPointer(3, GL_FLOAT, 0, mesh.vertices);
+ noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
{
glEnableClientState(GL_NORMAL_ARRAY);
- glNormalPointer(/*mesh.flags.doubleNormals ? GL_DOUBLE : */GL_FLOAT, 0, mesh.normals);
+ noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
}
else
glDisableClientState(GL_NORMAL_ARRAY);
if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- glTexCoordPointer(2, GL_FLOAT, 0, mesh.texCoords);
+ noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
}
else
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
{
glEnableClientState(GL_COLOR_ARRAY);
- glColorPointer(4, GL_FLOAT, 0, mesh.colors);
+ noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
}
else
glDisableClientState(GL_COLOR_ARRAY);
}
-#if !defined(__ANDROID__) && !defined(__APPLE__)
+#if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
#if defined(__WIN32__)
if(glLockArraysEXT)
#endif
}
- else
- GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
}
void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
}
else*/
#endif
+
{
OGLIndices oglIndices = primitive->data;
+ GLEAB eab = ((!display.display3D.collectingHits && oglIndices) ? oglIndices.buffer : noEAB);
- if(!display.display3D.collectingHits && vboAvailable && oglIndices)
- {
- GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
- if(primitive->type.indices32bit)
- glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, 0);
- else
- glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
- GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
- }
- else
- {
- if(primitive->type.indices32bit)
- glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
- oglIndices ? oglIndices.indices : primitive->indices);
- else
- glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
- GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
- }
+ eab.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
+ primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT,
+ eab.buffer ? 0 : (oglIndices ? oglIndices.indices : primitive->indices));
+ GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
}
}
#if defined(__WIN32__)
OGLSystem system = displaySystem.driverData;
return system.glrc;
-#elif !defined(__ANDROID__)
+#elif defined(__ANDROID__) || defined(__ODROID__)
+ return eglContext;
+#elif defined(__EMSCRIPTEN__)
+#else
OGLSystem system = displaySystem.driverData;
return system.glContext;
-#else
- return eglContext;
#endif
}
return null;
Ecere Software / sdk / blobdiff