return false;
}
-public class Object
+public class Object : struct
{
public:
void SetMinMaxRadius(bool processMesh)
import "Object"
-#if !defined(_GLES)
+#if defined(__EMSCRIPTEN__)
+#define ES2
+#endif
+
+#if defined(__ANDROID__) || defined(__ODROID__)
+#define ES1_1
+#endif
+
+#if !defined(ES1_1) && !defined(ES2)
#define USE_32_BIT_INDICES true
#define indicesMember indices32
#define uintindex uint32
};
#if !defined(ECERE_VANILLA) && !defined(ECERE_NO3D)
-private class Display3D
+private class Display3D : struct
{
// 3D Display
int nTriangles;
namespace gfx::drivers;
#if defined(_GLES)
-#define ES1_1
+ #define ES1_1
#else
- #define SHADERS
+ #define SHADERS
#endif
#if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
// #define USEPBUFFER
#if defined(__unix__) || defined(__APPLE__)
-#if !defined(__MINGW32__)
- #define GL_GLEXT_PROTOTYPES
-#endif
+ #if !defined(__MINGW32__)
+ #define GL_GLEXT_PROTOTYPES
+ #endif
-#define pointer _pointer
+ #define pointer _pointer
#if !defined(__ANDROID__) && !defined(__ODROID__) && !defined(__EMSCRIPTEN__)
#endif
#if defined(__APPLE__)
-#include <OpenGl/gl.h>
+ #include <OpenGl/gl.h>
#endif
#if defined(__WIN32__) || defined(__unix__) || defined(__APPLE__)
-#if defined(__WIN32__)
- //#define WIN32_LEAN_AND_MEAN
- #undef _WIN32_WINNT
- #define _WIN32_WINNT 0x0502
- #define String Sting_
- #include <windows.h>
- #undef String
-#endif
+ #if defined(__WIN32__)
+ //#define WIN32_LEAN_AND_MEAN
+ #undef _WIN32_WINNT
+ #define _WIN32_WINNT 0x0502
+ #define String Sting_
+ #include <windows.h>
+ #undef String
+ #endif
-#if defined(__ANDROID__) || defined(__ODROID__)
+ #if defined(__ANDROID__) || defined(__ODROID__)
+ #if defined(__ODROID__) && !defined(ES1_1)
+ #define ES1_1
+ #endif
-#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>
-
-#undef Bool
-#undef Picture
-#undef Window
-#undef Cursor
-#undef Font
-#undef Display
-#undef Time
-#undef KeyCode
-#undef uint
-#undef new
-#undef property
-#undef class
+ #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
-#elif defined(__EMSCRIPTEN__)
+ #include <GLES/gl.h>
- #define property _property
- #define uint _uint
+ #undef Bool
+ #undef Picture
+ #undef Window
+ #undef Cursor
+ #undef Font
+ #undef Display
+ #undef Time
+ #undef KeyCode
+ #undef uint
+ #undef new
+ #undef property
+ #undef class
- #include <GL/gl.h>
+ #elif defined(__EMSCRIPTEN__)
+ #define ES2
+ // #define ES1_1
- //#include <GLES/gl.h>
- //#include <GLES2/gl.h>
- #include <GL/glfw.h>
- #include <emscripten/emscripten.h>
+ #define property _property
+ #define uint _uint
- #undef property
- #undef uint
+ //#include <GL/gl.h>
+ //#include <GLES/gl.h>
+ #include <GLES2/gl2.h>
-#else
- #include <GL/gl.h>
-#endif
+ #include <emscripten/emscripten.h>
+ #include <emscripten/html5.h>
-#if defined(__ODROID__) && !defined(ES1_1)
-#define ES1_1
-#endif
+ #undef property
+ #undef uint
-#if defined(__EMSCRIPTEN__)
-#define EM_MODE
-// #define ES1_1
-#endif
+ #else
+ #include <GL/gl.h>
+ #endif
-#undef pointer
+ #undef pointer
-import "Display"
+ import "Display"
-#if defined(__unix__) || defined(__APPLE__)
+ #if defined(__unix__) || defined(__APPLE__)
#if !defined(__ANDROID__) && !defined(__ODROID__) && !defined(__EMSCRIPTEN__)
import "XInterface"
#endif
-#endif
+ #endif
-#define glLoadMatrix glLoadMatrixd
-#define glMultMatrix glMultMatrixd
-#define glGetMatrix glGetDoublev
-#define glTranslate glTranslated
-#define glScale glScaled
+ #define glLoadMatrix glLoadMatrixd
+ #define glMultMatrix glMultMatrixd
+ #define glGetMatrix glGetDoublev
+ #define glTranslate glTranslated
+ #define glScale glScaled
/*
#define glVertex3v glVertex3dv
static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = null;
static PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = null;
-#elif defined(__ANDROID__) || defined(__ODROID__)
+#else
+#if 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_BGRA_EXT 0
+#endif
+
+#if defined(__ANDROID__) || defined(__ODROID__) || defined(__EMSCRIPTEN__)
#define GL_POLYGON_STIPPLE 0xFFFF
#define GL_LINE_STIPPLE 0xFFFF
//#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_PACK_ROW_LENGTH 0
#define GL_PACK_SKIP_ROWS 0
#define GL_PACK_SKIP_PIXELS 0
+#endif
#endif
#define glGenRenderbuffers glGenRenderbuffersOES
#define glDeleteFramebuffers glDeleteFramebuffersOES
#define glDeleteRenderbuffers glDeleteRenderbuffersOES
+#endif
+#if defined(__ANDROID__) || defined(__ODROID__) || defined(__EMSCRIPTEN__)
#define GL_INT 0x1404
#define GL_UNSIGNED_INT 0x1405
#define GL_DOUBLE 0x140A
#define APIENTRY
#endif
-#if defined(ES1_1) || defined(SHADERS)
+#if defined(ES1_1) || defined(ES2) || defined(SHADERS)
#undef glRecti
#undef glBegin
}
static GLuint stippleTexture;
-#if defined(ES1_1) || defined(SHADERS) || defined(EM_MODE)
+#if defined(ES1_1) || defined(ES2) || defined(SHADERS)
static bool stippleEnabled;
#endif
public void glesLightModeli( unsigned int pname, int param )
{
-#if !defined(EM_MODE) && !defined(SHADERS)
+#if !defined(SHADERS)
if(pname == GL_LIGHT_MODEL_TWO_SIDE)
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
#endif
}
-#if defined(__ANDROID__) || defined(__ODROID__)
+#if defined(__ANDROID__) || defined(__ODROID__) || defined(__EMSCRIPTEN__)
void glClearDepth( double depth ) { glClearDepthf((float)depth); }
+#endif
+
+#if defined(__ANDROID__) || defined(__ODROID__)
void glFogi( unsigned int pname, int param ) { }
void glPolygonMode( unsigned int i, unsigned int j ) { }
#if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
static int primitiveTypes[RenderPrimitiveType] =
{
- GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GLIMTKMode::quads, GLIMTKMode::quadStrip, GL_LINE_STRIP
+ GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN,
+#if defined(SHADERS) || defined(ES1_1) || defined(ES2)
+ GL_TRIANGLE_FAN, // NOTE: This will only work for single quads
+#else
+ GLIMTKMode::quads,
+#endif
+ GLIMTKMode::quadStrip,
+ GL_LINE_STRIP
};
#endif
{
#ifdef SHADERS
shader_fog(enable);
-#elif !defined(EM_MODE)
+#else
(enable ? glEnable : glDisable)(GL_FOG);
#endif
}
{
#if defined(SHADERS)
shader_lighting(enable);
-#elif !defined(EM_MODE)
+#else
(enable ? glEnable : glDisable)(GL_LIGHTING);
#endif
}
// Non OpenGL ES friendly stuff
-#if defined(ES1_1)
+#if defined(ES1_1) || defined(ES2)
//#undef GL_UNSIGNED_INT
//#undef GL_DOUBLE
HDC hdc;
HGLRC glrc;
HWND hwnd;
-#elif !defined(__ANDROID__) && !defined(__ODROID__) && !defined(__EMSCRIPTEN__)
+#elif defined(__EMSCRIPTEN__)
+ EMSCRIPTEN_WEBGL_CONTEXT_HANDLE glc;
+#elif !defined(__ANDROID__) && !defined(__ODROID__)
XVisualInfo * visualInfo;
GLXContext glContext;
GLXDrawable glxDrawable;
int current;
void * previous;
+#if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
+#ifdef _DEBUG
static void setupDebugging()
{
-#ifdef _DEBUG
if(glDebugMessageCallback)
{
GLuint unusedIds = 0;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+ /*
glDebugMessageCallback(openglCallbackFunction, null);
glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE,
0,
&unusedIds,
GL_TRUE);
+ */
}
-#endif
}
+#endif
+#endif
#if defined(__WIN32__)
static HGLRC winCreateContext(HDC hdc)
bool LockSystem(DisplaySystem displaySystem)
{
-#if !defined(__ANDROID__) && !defined(__ODROID__) && !defined(__EMSCRIPTEN__)
+#if defined(__EMSCRIPTEN__)
+ OGLSystem oglSystem = displaySystem.driverData;
+ emscripten_webgl_make_context_current(oglSystem.glc);
+#elif !defined(__ANDROID__) && !defined(__ODROID__)
OGLSystem oglSystem = displaySystem.driverData;
if(useSingleGLContext) return true;
#if defined(__WIN32__)
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();
+ EmscriptenWebGLContextAttributes attribs = { 0 };
+ attribs.depth = 1;
+ attribs.antialias = 1;
+
+ /*
+ EM_BOOL alpha;
+ EM_BOOL depth;
+ EM_BOOL stencil;
+ EM_BOOL antialias;
+ EM_BOOL premultipliedAlpha;
+ EM_BOOL preserveDrawingBuffer;
+ EM_BOOL preferLowPowerToHighPerformance;
+ EM_BOOL failIfMajorPerformanceCaveat;
+ int majorVersion;
+ int minorVersion;
+ EM_BOOL enableExtensionsByDefault;
+ */
+
+ emscripten_webgl_init_context_attributes(&attribs);
+ oglSystem.pow2textures = true;
+ oglSystem.maxTextureSize = 16384;
+ oglSystem.glc = emscripten_webgl_create_context("canvas", &attribs);
+ if(emscripten_webgl_make_context_current(oglSystem.glc) == EMSCRIPTEN_RESULT_SUCCESS)
result = true;
- }
- else
- printf("glfwOpenWindow() failed\n"); //glfwTerminate();
+
+ /*glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glEnable(GL_BLEND);*/
}
- else
- printf("glfwInit() failed\n"); //glfwTerminate();
#else
{
X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
stippleTexture = 0;
}
+ glimtkTerminate();
+
#if defined(__WIN32__)
wglMakeCurrent( null, null );
#if defined(__ANDROID__) || defined(__ODROID__)
egl_term_display();
#elif defined(__EMSCRIPTEN__)
- glfwTerminate();
+ emscripten_webgl_destroy_context(oglSystem.glc);
#else
if(oglSystem.visualInfo)
{
{
bool result = false;
OGLDisplay oglDisplay = display.driverData;
-#if !defined(__ANDROID__) && !defined(__ODROID__) && !defined(__EMSCRIPTEN__)
+#if !defined(__ANDROID__) && !defined(__ODROID__)
OGLSystem oglSystem = display.displaySystem.driverData;
#endif
if(!display.alphaBlend)
#endif
{
- #if defined(__WIN32__)
+#if defined(__WIN32__)
oglDisplay.hdc = GetDC(display.window);
SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
if((oglDisplay.glrc = winCreateContext(oglDisplay.hdc)))
}
else
ReleaseDC(display.window, oglDisplay.hdc);
- #elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__) || defined(__ODROID__) || defined(__EMSCRIPTEN__)
- #else
+#elif defined(__unix__) || defined(__APPLE__)
+# if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+ result = true;
+# else
XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
/*
#if defined(__APPLE__)
glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
result = true;
}
- #endif
- #endif
+# endif
+#endif
}
#if defined(__WIN32__) || defined(USEPBUFFER)
else
#ifdef DIAGNOSTICS
PrintLn("Calling ogl_LoadFunctions() in CreateDisplay()");
#endif
- ogl_LoadFunctions();
+ if(ogl_LoadFunctions() == ogl_LOAD_FAILED)
+ PrintLn("ogl_LoadFunctions() failed!");
+
#ifdef DIAGNOSTICS
PrintLn("CheckExtensions()");
#endif
PrintLn("vboAvailable is: ", vboAvailable);
#endif
-#ifdef _DEBUG
+# ifdef _DEBUG
setupDebugging();
- initialDisplaySetup(display);
+# endif
+
#endif
+#if defined(__EMSCRIPTEN__)
+ emscripten_webgl_make_context_current(oglSystem.glc);
#endif
+
+ initialDisplaySetup(display);
}
if(!useSingleGLContext)
#if defined(__WIN32__)
wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
#elif defined(__unix__) || defined(__APPLE__)
- #if defined(__ANDROID__) || defined(__ODROID__) || defined(__EMSCRIPTEN__)
+ #if defined(__ANDROID__) || defined(__ODROID__)
width = eglWidth;
height = eglHeight;
+ #elif defined(__EMSCRIPTEN__)
+ emscripten_webgl_make_context_current(oglSystem.glc);
#else
glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
#endif
{
oglDisplay.flipBufW = width;
oglDisplay.flipBufH = height;
-#ifdef ES1_1
+#if defined(ES1_1) || defined(ES2)
result = true;
#else
oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
#if defined(__WIN32__)
//wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
SwapBuffers(oglDisplay.hdc);
+ //ecere::sys::Sleep(0.1);
#elif defined(__unix__) || defined(__APPLE__)
#if defined(__ANDROID__) || defined(__ODROID__)
egl_swap_buffers();
#elif defined(__EMSCRIPTEN__)
- glfwSwapBuffers();
#else
glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
#endif
glColor4fv(oglSurface.foreground);
glBegin(GL_LINES);
-#if defined(ES1_1) || defined(EM_MODE) || defined(SHADERS)
+#if defined(ES1_1) || defined(ES2) || defined(SHADERS)
if(stippleEnabled)
{
glTexCoord2f(0.5f, 0);
//Logf("Rectangle\n");
glColor4fv(oglSurface.foreground);
-#if defined(ES1_1) || defined(EM_MODE) || defined(SHADERS)
+#if defined(ES1_1) || defined(ES2) || defined(SHADERS)
if(stippleEnabled)
{
glBegin(GL_LINES);
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(ES1_1) || defined(EM_MODE) || defined(SHADERS)
+#if defined(ES1_1) || defined(ES2) || defined(SHADERS)
stippleEnabled = true;
glesLineStipple(1, (uint16)stipple);
#else
}
else
{
-#if defined(ES1_1) || defined(EM_MODE) || defined(SHADERS)
+#if defined(ES1_1) || defined(ES2) || defined(SHADERS)
stippleEnabled = false;
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
#endif
}
}
+
#if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
void SetRenderState(Display display, RenderState state, uint value)
{
switch(state)
{
case antiAlias:
+#ifndef __EMSCRIPTEN__
if(value)
glEnable(GL_MULTISAMPLE_ARB);
else
glDisable(GL_MULTISAMPLE_ARB);
+#endif
break;
case fillMode:
-#if !defined(ES1_1)
+#if !defined(ES1_1) && !defined(ES2)
glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
#endif
break;
#endif
break;
case blend:
+//#if !defined(__EMSCRIPTEN__)
if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
+//#endif
break;
case ambient:
{
#if defined(SHADERS)
shader_setGlobalAmbient(((Color)value).r / 255.0f, ((Color)value).g / 255.0f, ((Color)value).b / 255.0f, 1.0f);
-#elif !defined(EM_MODE)
+#else
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
{
#if defined(SHADERS)
shader_setLight(display, id, light);
-#elif !defined(EM_MODE)
+#else
//Logf("SetLight\n");
if(light != null)
glEnable(GL_DEPTH_TEST);
GLSetupLighting(true);
-#if !defined(EM_MODE) && !defined(SHADERS)
+#if !defined(SHADERS)
glShadeModel(GL_SMOOTH);
#endif
glDepthMask((byte)bool::true);
oglDisplay.depthWrite = true;
+#ifndef __EMSCRIPTEN__
glEnable(GL_MULTISAMPLE_ARB);
+#endif
}
else if(surface && display.display3D.camera)
{
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
+
GLSetupTexturing(false);
GLSetupLighting(false);
GLSetupFog(false);
glDisableClientState(GL_COLOR_ARRAY);
-#if !defined(SHADERS) && !defined(EM_MODE)
+#if defined(SHADERS)
+ shader_setPerVertexColor(false);
+#else
glShadeModel(GL_FLAT);
#endif
glEnable(GL_BLEND);
+#if !defined(__EMSCRIPTEN__)
glDisable(GL_MULTISAMPLE_ARB);
+#endif
// *** Restore 2D MODELVIEW Matrix ***
glPopMatrix();
// Basic Properties
if(material.flags.doubleSided)
{
-#if !defined(EM_MODE) && !defined(SHADERS)
+#if !defined(SHADERS)
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
#endif
glDisable(GL_CULL_FACE);
}
else
{
-#if !defined(EM_MODE) && !defined(SHADERS)
+#if !defined(SHADERS)
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
#endif
glEnable(GL_CULL_FACE);
#if defined(SHADERS)
shader_setMaterial(material, mesh.flags.colors);
-#elif defined(EM_MODE)
- glimtkColor4f(material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity);
#else
if(mesh.flags.colors)
{
{
if(vboAvailable)
{
-#ifdef ES1_1
+#if defined(ES1_1) || defined(ES2)
if(indices32bit)
{
if(!oglIndices.buffer.buffer)
#elif defined(__ANDROID__) || defined(__ODROID__)
return eglContext;
#elif defined(__EMSCRIPTEN__)
+ OGLSystem system = displaySystem.driverData;
+ return (void *)system.glc;
#else
OGLSystem system = displaySystem.driverData;
return system.glContext;
-#version 150
+#version 100
+
+precision highp float;
uniform sampler2D diffuseTex;
uniform bool texturingOn;
uniform mat4 texture_matrix;
uniform bool matTwoSided;
+/*
in vec2 fTexCoord;
in vec4 fColor;
in vec4 fColorBack;
+*/
+
+varying vec2 fTexCoord;
+varying vec4 fColor;
+varying vec4 fColorBack;
-out vec4 fragColor;
+// out vec4 fragColor;
void main(void)
{
vec4 c = (matTwoSided && lightingOn && !gl_FrontFacing) ? fColorBack : fColor;
- fragColor = texturingOn ? c * texture(diffuseTex, (vec4(fTexCoord, 0, 1) * texture_matrix).xy) : c;
+ gl_FragColor = texturingOn ? c * texture2D(diffuseTex, (vec4(fTexCoord, 0, 1) * texture_matrix).xy) : c;
}
-#version 150
+#version 100
uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;
uniform float fogDensity;
uniform vec3 fogColor;
+/*
in vec2 texCoord;
in vec3 vertex;
in vec3 normal;
out vec2 fTexCoord;
out vec4 fColor;
out vec4 fColorBack;
+*/
+
+attribute vec2 texCoord;
+attribute vec3 vertex;
+attribute vec3 normal;
+attribute vec4 color;
+
+varying vec2 fTexCoord;
+varying vec4 fColor;
+varying vec4 fColorBack;
void main(void)
{
- float f = 1;
- vec3 n = normalize(mat3x3(modelview_matrix) * normal);
+ float f = 1.0;
+ vec3 n = normalize(mat3(modelview_matrix) * normal);
vec4 pos = modelview_matrix * vec4(vertex, 1.0);
gl_Position = projection_matrix * pos;
fTexCoord = texCoord;
if(fogOn)
- f = clamp(exp(fogDensity * pos.z), 0, 1);
+ f = clamp(exp(fogDensity * pos.z), 0.0, 1.0);
if(lightingOn)
{
- int i;
vec3 diffuseColor = perVertexColor ? color.xyz : matDiffuse;
vec3 ambientColor = perVertexColor ? color.xyz : matAmbient;
float opacity = perVertexColor ? color.w : matOpacity;
fColor = vec4(0);
if(matTwoSided)
fColorBack = vec4(0);
- for(i = 0; i < 8; i++)
+ for(int i = 0; i < 8; i++)
if(lightsOn[i])
{
vec4 l = lightsPos[i];
float d = dot(n, l.xyz);
- float pf = 0;
+ float pf = 0.0;
vec3 VP = l.xyz;
vec3 halfVector;
if(matPower != 0.0)
float nDotVP;
VP = l.xyz;
halfVector = normalize(VP + eye);
- nDotVP = max(0, dot(n, VP));
+ nDotVP = max(0.0, dot(n, VP));
if(nDotVP != 0.0)
{
float nDotHV = max(0.0, dot(n, halfVector));
}
}
- c += diffuseColor * min(1, max(0, d)) * lightsDiffuse[i];
+ c += diffuseColor * min(1.0, max(0.0, d)) * lightsDiffuse[i];
c += matSpecular * pf * lightsSpecular[i];
c += matAmbient * lightsAmbient[i];
float d2 = dot(iN, l.xyz);
if(matPower != 0.0)
{
- float nDotVP = max(0, dot(iN, VP));
+ float nDotVP = max(0.0, dot(iN, VP));
if(nDotVP != 0.0)
{
float nDotHV = max(0.0, dot(iN, halfVector));
}
}
- c2 += diffuseColor * min(1, max(0, d2)) * lightsDiffuse[i];
+ c2 += diffuseColor * min(1.0, max(0.0, d2)) * lightsDiffuse[i];
c2 += matSpecular * pf * lightsSpecular[i];
c2 += matAmbient * lightsAmbient[i];
}
fColor = vec4(c, opacity);
if(fogOn)
- fColor = f * fColor + (1-f) * vec4(fogColor, 1);
+ fColor = f * fColor + (1.0-f) * vec4(fogColor, 1);
if(matTwoSided)
{
fColorBack = vec4(c2, opacity);
if(fogOn)
- fColorBack = f * fColorBack + (1-f) * vec4(fogColor, 1);
+ fColorBack = f * fColorBack + (1.0-f) * vec4(fogColor, 1);
}
}
else
{
- fColor = current_color * color;
+ fColor = current_color * (perVertexColor ? color : vec4(1,1,1,1));
if(fogOn)
- fColor = f * fColor + (1-f) * vec4(fogColor, 1);
+ fColor = f * fColor + (1.0-f) * vec4(fogColor, 1);
}
}
#define SHADERS
#endif
-#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
#include <GLES/gl.h>
#define GL_INT 0x1404
#define GL_DOUBLE 0x140A
+#elif defined(__EMSCRIPTEN__)
+ #include <GLES2/gl2.h>
+
+ #define ES2
+
+ #define GL_INT 0x1404
+ #define GL_DOUBLE 0x140A
#else
# if defined(SHADERS)
# include "gl_core_3_3.h"
void useVertTrans(uint count, int n, int type, uint stride, void * pointer)
{
-#if defined(_GLES) || defined(ES1_1)
+#if defined(_GLES) || defined(ES1_1) || defined(ES2)
if(glabCurArrayBuffer != ((this != null) ? buffer : 0))
GLABBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
if(type == GL_INT)
if(glabCurElementBuffer != buffer)
GLABBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
+ if(size)
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
+ else
+ ;
}
}
{
if(glabCurElementBuffer != ((this != null) ? buffer : 0))
GLABBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
-#if defined(_GLES) || defined(ES1_1)
+#if defined(_GLES) || defined(ES1_1) || defined(ES2)
type = GL_UNSIGNED_SHORT;
#endif
glDrawElements(primType, count, type, indices);
#define SHADERS
#endif
-#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
#include <GLES/gl.h>
+#elif defined(__EMSCRIPTEN__)
+ #include <GLES2/gl2.h>
#else
# if defined(SHADERS)
# include "gl_core_3_3.h"
#endif
import "glab"
+import "shading"
#ifdef SHADERS
public void glimtkVertex2i(int x, int y) { glimtkVertex2f((float)x, (float)y); }
public void glimtkVertex2d(double x, double y) { glimtkVertex2f((float)x, (float)y); }
+GLAB streamVecAB, streamNorAB;
+
public void glimtkEnd(void)
{
GLIMTKMode mode = beginMode;
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- noAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
+ streamVecAB.upload(vertexStride * sizeof(float) * vertexCount, vertexPointer);
+
+ streamVecAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), 0);
+ // 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);
+ streamVecAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), (void *)(2 * sizeof(float)));
+
+#ifdef SHADERS
+ shader_setPerVertexColor(true);
+#endif
+
+
+ //noAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
}
- noAB.use(vertex, numVertexCoords, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + vertexOffset);
+ streamVecAB.use(vertex, numVertexCoords, GL_FLOAT, vertexStride * sizeof(float), (void *)(vertexOffset * sizeof(float)));
+ // noAB.use(vertex, numVertexCoords, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + vertexOffset);
if(normalCount && normalCount == vertexCount)
{
glEnableClientState(GL_NORMAL_ARRAY);
- noAB.use(normal, 3, GL_FLOAT, 3*sizeof(float),normalPointer);
+ streamNorAB.upload(3*sizeof(float) * vertexCount, normalPointer);
+ streamNorAB.use(normal, 3, GL_FLOAT, 3*sizeof(float), 0);
+ // 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);
+
+#ifdef SHADERS
+ shader_setPerVertexColor(false);
+#endif
+
+ }
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
normalCount = 0;
#define SHADERS
#endif
-#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
#include <GLES/gl.h>
+#elif defined(__EMSCRIPTEN__)
+ #include <GLES2/gl2.h>
#else
# if defined(SHADERS)
# include "gl_core_3_3.h"
#endif
import "Display"
+import "shading"
#if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
public union Matrix
import "Display"
import "matrixStack"
+import "glab"
#ifndef _GLES
#define SHADERS
#if defined(SHADERS)
-#if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
+#if defined(__ANDROID__) || defined(__ODROID__)
#include <GLES/gl.h>
#define GL_INT 0x1404
#define GL_DOUBLE 0x140A
+#elif defined(__EMSCRIPTEN__)
+ #include <GLES2/gl2.h>
#else
# if defined(SHADERS)
# include "gl_core_3_3.h"
void shader_lighting(bool on)
{
- glUniform1ui(uLightingOn, on);
+ glUniform1i(uLightingOn, on);
}
void shader_fog(bool on)
{
- glUniform1ui(uFogOn, on);
+ glUniform1i(uFogOn, on);
}
void shader_fogDensity(float density)
void shader_texturing(bool on)
{
- glUniform1ui(uTexturingOn, on);
+ glUniform1i(uTexturingOn, on);
}
public void shader_setMaterial(Material material, bool perVertexColor)
{
- glUniform1ui(uPerVertexColor, perVertexColor);
- glUniform1ui(uMatTwoSided, !material.flags.singleSideLight);
+ glUniform1i(uPerVertexColor, perVertexColor);
+ glUniform1i(uMatTwoSided, !material.flags.singleSideLight);
glUniform3f(uMatDiffuse, material.diffuse.r, material.diffuse.g, material.diffuse.b);
glUniform3f(uMatAmbient, material.ambient.r, material.ambient.g, material.ambient.b);
glUniform3f(uMatSpecular, material.specular.r, material.specular.g, material.specular.b);
glUniform1i(uLightsOn[id], 0);
}
-void loadShaders(const String vertexShaderFile, const String fragmentShaderFile)
+bool loadShaders(const String vertexShaderFile, const String fragmentShaderFile)
{
- static char compileLog[65536];
- #define BUFFER_SIZE 4096
- int bufferLen = BUFFER_SIZE;
- char * buffer = new byte[BUFFER_SIZE];
- int vsLen = 0, fsLen = 0;
- char * vsSource = null;
- char * psSource = null;
+ bool result = false;
File vf = FileOpen(vertexShaderFile, read);
File ff = FileOpen(fragmentShaderFile, read);
-
- if(vf)
+ // printf("loading shaders %s and %s (%p and %p)\n", vertexShaderFile, fragmentShaderFile, vf, ff);
+ if(vf && ff)
{
- while(!vf.eof)
+ static char compileLog[65536];
+ #define BUFFER_SIZE 4096
+ int bufferLen = BUFFER_SIZE;
+ char * buffer = new byte[BUFFER_SIZE];
+ int vsLen = 0, fsLen = 0;
+ char * vsSource = null;
+ char * psSource = null;
+ if(vf)
{
- int count = vf.Read(buffer + vsLen, 1, BUFFER_SIZE);
- vsLen += count;
- if(count == BUFFER_SIZE && bufferLen < vsLen + BUFFER_SIZE)
+ while(!vf.eof)
{
- bufferLen = vsLen + BUFFER_SIZE;
- buffer = renew buffer byte[bufferLen];
+ int count = vf.Read(buffer + vsLen, 1, BUFFER_SIZE);
+ vsLen += count;
+ if(count == BUFFER_SIZE && bufferLen < vsLen + BUFFER_SIZE)
+ {
+ bufferLen = vsLen + BUFFER_SIZE;
+ buffer = renew buffer byte[bufferLen];
+ }
}
+ vsSource = new byte[vsLen+1];
+ memcpy(vsSource, buffer, vsLen);
+ vsSource[vsLen] = 0;
+ delete vf;
}
- vsSource = new byte[vsLen+1];
- memcpy(vsSource, buffer, vsLen);
- vsSource[vsLen] = 0;
- delete vf;
- }
- if(ff)
- {
- while(!ff.eof)
+ if(ff)
{
- int count = ff.Read(buffer + fsLen, 1, BUFFER_SIZE);
- fsLen += count;
- if(count == BUFFER_SIZE && bufferLen < fsLen + BUFFER_SIZE)
+ while(!ff.eof)
{
- bufferLen = fsLen + BUFFER_SIZE;
- buffer = renew buffer byte[bufferLen];
+ int count = ff.Read(buffer + fsLen, 1, BUFFER_SIZE);
+ fsLen += count;
+ if(count == BUFFER_SIZE && bufferLen < fsLen + BUFFER_SIZE)
+ {
+ bufferLen = fsLen + BUFFER_SIZE;
+ buffer = renew buffer byte[bufferLen];
+ }
}
+ psSource = new byte[fsLen+1];
+ memcpy(psSource, buffer, fsLen);
+ psSource[fsLen] = 0;
+ delete ff;
}
- psSource = new byte[fsLen+1];
- memcpy(psSource, buffer, fsLen);
- psSource[fsLen] = 0;
- delete ff;
- }
- delete buffer;
+ delete buffer;
- printf("We've got OpenGL Version %s\n\n", (char *)glGetString(GL_VERSION));
- printf("We've got Shading Language Version %s\n\n", (char *)glGetString(GL_SHADING_LANGUAGE_VERSION));
+ printf("We've got OpenGL Version %s\n\n", (char *)glGetString(GL_VERSION));
+ printf("We've got Shading Language Version %s\n\n", (char *)glGetString(GL_SHADING_LANGUAGE_VERSION));
- {
- int program = glCreateProgram();
- int vShader = glCreateShader(GL_VERTEX_SHADER);
- int fShader = glCreateShader(GL_FRAGMENT_SHADER);
- const char * vptr[1] = { vsSource };
- const char * fptr[1] = { psSource };
- int i;
-
- glShaderSource(vShader, 1, vptr, &vsLen);
- glShaderSource(fShader, 1, fptr, &fsLen);
- delete vsSource;
- delete psSource;
-
- glCompileShader(vShader);
- glGetShaderInfoLog(vShader, sizeof(compileLog), null, compileLog);
- puts("Vertex Shader Compile Log:");
- puts("--------------------------");
- puts(compileLog[0] ? compileLog : "Success.");
-
- glCompileShader(fShader);
- glGetShaderInfoLog(fShader, sizeof(compileLog), null, compileLog);
- puts("");
- puts("");
- puts("Fragment Shader Compile Log:");
- puts("--------------------------");
- puts(compileLog[0] ? compileLog : "Success.");
-
- glAttachShader(program, vShader);
- glAttachShader(program, fShader);
-
- glBindAttribLocation(program, GLBufferContents::vertex, "vertex");
- glBindAttribLocation(program, GLBufferContents::texCoord, "texCoord");
- glBindAttribLocation(program, GLBufferContents::color, "color");
- glBindAttribLocation(program, GLBufferContents::normal, "normal");
- glBindFragDataLocation(program, 0, "fragColor");
-
- glLinkProgram(program);
- glValidateProgram(program);
-
- glGetProgramInfoLog(program, sizeof(compileLog), null, compileLog);
- puts("");
- puts("");
- puts("Shader Program Log:");
- puts("--------------------------");
- puts(compileLog[0] ? compileLog : "Success.");
-
- uPrjMatrix = glGetUniformLocation(program, "projection_matrix");
- uMVMatrix = glGetUniformLocation(program, "modelview_matrix");
- uTextureMatrix = glGetUniformLocation(program, "texture_matrix");
- uColor = glGetUniformLocation(program, "current_color");
- uTexturingOn = glGetUniformLocation(program, "texturingOn");
- uLightingOn = glGetUniformLocation(program, "lightingOn");
- uFogOn = glGetUniformLocation(program, "fogOn");
- uFogDensity = glGetUniformLocation(program, "fogDensity");
- uFogColor = glGetUniformLocation(program, "fogColor");
- uGlobalAmbient = glGetUniformLocation(program, "globalAmbient");
- uPerVertexColor = glGetUniformLocation(program, "perVertexColor");
- uMatDiffuse = glGetUniformLocation(program, "matDiffuse");
- uMatAmbient = glGetUniformLocation(program, "matAmbient");
- uMatSpecular = glGetUniformLocation(program, "matSpecular");
- uMatEmissive = glGetUniformLocation(program, "matEmissive");
- uMatPower = glGetUniformLocation(program, "matPower");
- uMatOpacity = glGetUniformLocation(program, "matOpacity");
- uMatTwoSided = glGetUniformLocation(program, "matTwoSided");
-
- for(i = 0; i < 8; i++)
{
- char name[100];
+ int program = glCreateProgram();
+ int vShader = glCreateShader(GL_VERTEX_SHADER);
+ int fShader = glCreateShader(GL_FRAGMENT_SHADER);
+ const char * vptr[1] = { vsSource };
+ const char * fptr[1] = { psSource };
+ int i;
+
+ glShaderSource(vShader, 1, vptr, &vsLen);
+ glShaderSource(fShader, 1, fptr, &fsLen);
+ delete vsSource;
+ delete psSource;
+
+ glCompileShader(vShader);
+ glGetShaderInfoLog(vShader, sizeof(compileLog), null, compileLog);
+ puts("Vertex Shader Compile Log:");
+ puts("--------------------------");
+ puts(compileLog[0] ? compileLog : "Success.");
+
+ glCompileShader(fShader);
+ glGetShaderInfoLog(fShader, sizeof(compileLog), null, compileLog);
+ puts("");
+ puts("");
+ puts("Fragment Shader Compile Log:");
+ puts("--------------------------");
+ puts(compileLog[0] ? compileLog : "Success.");
+
+ glAttachShader(program, vShader);
+ glAttachShader(program, fShader);
+
+ glBindAttribLocation(program, GLBufferContents::vertex, "vertex");
+ glBindAttribLocation(program, GLBufferContents::texCoord, "texCoord");
+ glBindAttribLocation(program, GLBufferContents::color, "color");
+ glBindAttribLocation(program, GLBufferContents::normal, "normal");
+ // glBindFragDataLocation(program, 0, "fragColor");
+
+ glLinkProgram(program);
+ glValidateProgram(program);
+
+ glGetProgramInfoLog(program, sizeof(compileLog), null, compileLog);
+ puts("");
+ puts("");
+ puts("Shader Program Log:");
+ puts("--------------------------");
+ puts(compileLog[0] ? compileLog : "Success.");
+
+ uPrjMatrix = glGetUniformLocation(program, "projection_matrix");
+ uMVMatrix = glGetUniformLocation(program, "modelview_matrix");
+ uTextureMatrix = glGetUniformLocation(program, "texture_matrix");
+ uColor = glGetUniformLocation(program, "current_color");
+ uTexturingOn = glGetUniformLocation(program, "texturingOn");
+ uLightingOn = glGetUniformLocation(program, "lightingOn");
+ uFogOn = glGetUniformLocation(program, "fogOn");
+ uFogDensity = glGetUniformLocation(program, "fogDensity");
+ uFogColor = glGetUniformLocation(program, "fogColor");
+ uGlobalAmbient = glGetUniformLocation(program, "globalAmbient");
+ uPerVertexColor = glGetUniformLocation(program, "perVertexColor");
+ uMatDiffuse = glGetUniformLocation(program, "matDiffuse");
+ uMatAmbient = glGetUniformLocation(program, "matAmbient");
+ uMatSpecular = glGetUniformLocation(program, "matSpecular");
+ uMatEmissive = glGetUniformLocation(program, "matEmissive");
+ uMatPower = glGetUniformLocation(program, "matPower");
+ uMatOpacity = glGetUniformLocation(program, "matOpacity");
+ uMatTwoSided = glGetUniformLocation(program, "matTwoSided");
+
+ for(i = 0; i < 8; i++)
+ {
+ char name[100];
- sprintf(name, "lightsOn[%d]", i);
- uLightsOn [i] = glGetUniformLocation(program, name);
+ sprintf(name, "lightsOn[%d]", i);
+ uLightsOn [i] = glGetUniformLocation(program, name);
- sprintf(name, "lightsPos[%d]", i);
- uLightsPos[i] = glGetUniformLocation(program, name);
+ sprintf(name, "lightsPos[%d]", i);
+ uLightsPos[i] = glGetUniformLocation(program, name);
- sprintf(name, "lightsDiffuse[%d]", i);
- uLightsDiffuse[i] = glGetUniformLocation(program, name);
+ sprintf(name, "lightsDiffuse[%d]", i);
+ uLightsDiffuse[i] = glGetUniformLocation(program, name);
- sprintf(name, "lightsAmbient[%d]", i);
- uLightsAmbient[i] = glGetUniformLocation(program, name);
+ sprintf(name, "lightsAmbient[%d]", i);
+ uLightsAmbient[i] = glGetUniformLocation(program, name);
- sprintf(name, "lightsSpecular[%d]", i);
- uLightsSpecular[i] = glGetUniformLocation(program, name);
- }
+ sprintf(name, "lightsSpecular[%d]", i);
+ uLightsSpecular[i] = glGetUniformLocation(program, name);
+ }
+
+ shadingProgram = program;
- shadingProgram = program;
+ glUseProgram(shadingProgram);
- glUseProgram(shadingProgram);
+ // Initialize uniforms to defaults
+ glmsMatrixMode(texture);
+ glmsLoadIdentity();
+ glmsMatrixMode(projection);
+ glmsLoadIdentity();
+ glmsMatrixMode(modelView);
+ glmsLoadIdentity();
+ shader_color(1.0, 1.0, 1.0, 1.0);
- // Initialize uniforms to defaults
- glmsMatrixMode(texture);
- glmsLoadIdentity();
- glmsMatrixMode(projection);
- glmsLoadIdentity();
- glmsMatrixMode(modelView);
- glmsLoadIdentity();
- shader_color(1.0, 1.0, 1.0, 1.0);
+ result = true;
+ }
}
+ delete vf;
+ delete ff;
+
+ return result;
}
#endif
Ecere Software / sdk / commitdiff