X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=gl_backend.c;h=fcaeeb2d1d6f5fd7f4e6c5088f8cf8003997a2a6;hb=3161ae840da309834bd08f39be63777836fade71;hp=92f90ab71b1ea788d305cf62e361f1dae6fb9f81;hpb=2b5bf11a5c533a36544f9529f9be03ff3de9c482;p=xonotic%2Fdarkplaces.git diff --git a/gl_backend.c b/gl_backend.c index 92f90ab7..fcaeeb2d 100644 --- a/gl_backend.c +++ b/gl_backend.c @@ -2,10 +2,79 @@ #include "quakedef.h" #include "cl_collision.h" -cvar_t gl_mesh_drawrangeelements = {0, "gl_mesh_drawrangeelements", "1", "use glDrawRangeElements function if available instead of glDrawElements (for performance comparisons or bug testing)"}; -cvar_t gl_mesh_testmanualfeeding = {0, "gl_mesh_testmanualfeeding", "0", "use glBegin(GL_TRIANGLES);glTexCoord2f();glVertex3f();glEnd(); primitives instead of glDrawElements (useful to test for driver bugs with glDrawElements)"}; -cvar_t gl_mesh_prefer_short_elements = {CVAR_SAVE, "gl_mesh_prefer_short_elements", "1", "use GL_UNSIGNED_SHORT element arrays instead of GL_UNSIGNED_INT"}; -cvar_t gl_mesh_separatearrays = {0, "gl_mesh_separatearrays", "1", "use several separate vertex arrays rather than one combined stream"}; +// on GLES we have to use some proper #define's +#ifndef GL_FRAMEBUFFER +#define GL_FRAMEBUFFER 0x8D40 +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#endif +#ifndef GL_COLOR_ATTACHMENT1 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#endif +#ifndef GL_ARRAY_BUFFER +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#endif +#ifndef GL_TEXTURE0 +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#endif + +#ifndef GL_TEXTURE_3D +#define GL_TEXTURE_3D 0x806F +#endif +#ifndef GL_TEXTURE_CUBE_MAP +#define GL_TEXTURE_CUBE_MAP 0x8513 +#endif + + +#define MAX_RENDERTARGETS 4 + cvar_t gl_paranoid = {0, "gl_paranoid", "0", "enables OpenGL error checking and other tests"}; cvar_t gl_printcheckerror = {0, "gl_printcheckerror", "0", "prints all OpenGL error checks, useful to identify location of driver crashes"}; @@ -14,9 +83,6 @@ cvar_t r_renderview = {0, "r_renderview", "1", "enables rendering 3D views (you cvar_t r_waterwarp = {CVAR_SAVE, "r_waterwarp", "1", "warp view while underwater"}; cvar_t gl_polyblend = {CVAR_SAVE, "gl_polyblend", "1", "tints view while underwater, hurt, etc"}; cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1", "enables OpenGL dithering (16bit looks bad with this off)"}; -cvar_t gl_vbo = {CVAR_SAVE, "gl_vbo", "3", "make use of GL_ARB_vertex_buffer_object extension to store static geometry in video memory for faster rendering, 0 disables VBO allocation or use, 1 enables VBOs for vertex and triangle data, 2 only for vertex data, 3 for vertex data and triangle data of simple meshes (ones with only one surface)"}; -cvar_t gl_vbo_dynamicvertex = {CVAR_SAVE, "gl_vbo_dynamicvertex", "0", "make use of GL_ARB_vertex_buffer_object extension when rendering dynamic (animated/procedural) geometry such as text and particles"}; -cvar_t gl_vbo_dynamicindex = {CVAR_SAVE, "gl_vbo_dynamicindex", "0", "make use of GL_ARB_vertex_buffer_object extension when rendering dynamic (animated/procedural) geometry such as text and particles"}; cvar_t gl_fbo = {CVAR_SAVE, "gl_fbo", "1", "make use of GL_ARB_framebuffer_object extension to enable shadowmaps and other features using pixel formats different from the framebuffer"}; cvar_t v_flipped = {0, "v_flipped", "0", "mirror the screen (poor man's left handed mode)"}; @@ -36,9 +102,9 @@ int gl_maxdrawrangeelementsvertices; int gl_maxdrawrangeelementsindices; #ifdef DEBUGGL -int errornumber = 0; +int gl_errornumber = 0; -void GL_PrintError(int errornumber, char *filename, int linenumber) +void GL_PrintError(int errornumber, const char *filename, int linenumber) { switch(errornumber) { @@ -77,8 +143,8 @@ void GL_PrintError(int errornumber, char *filename, int linenumber) Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber); break; #endif -#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT - case GL_INVALID_FRAMEBUFFER_OPERATION_EXT: +#ifdef GL_INVALID_FRAMEBUFFER_OPERATION + case GL_INVALID_FRAMEBUFFER_OPERATION: Con_Printf("GL_INVALID_FRAMEBUFFER_OPERATION at %s:%i\n", filename, linenumber); break; #endif @@ -102,7 +168,8 @@ typedef struct gltextureunit_s const r_meshbuffer_t *pointer_texcoord_vertexbuffer; size_t pointer_texcoord_offset; - int t2d, t3d, tcubemap, trectangle; + rtexture_t *texture; + int t2d, t3d, tcubemap; int arrayenabled; int rgbscale, alphascale; int combine; @@ -119,13 +186,17 @@ typedef struct gl_state_s int cullfaceenable; int blendfunc1; int blendfunc2; - int blend; + qboolean blend; GLboolean depthmask; int colormask; // stored as bottom 4 bits: r g b a (3 2 1 0 order) int depthtest; + int depthfunc; float depthrange[2]; float polygonoffset[2]; int alphatest; + int alphafunc; + float alphafuncvalue; + qboolean alphatocoverage; int scissortest; unsigned int unit; unsigned int clientunit; @@ -135,6 +206,9 @@ typedef struct gl_state_s int lockrange_count; int vertexbufferobject; int elementbufferobject; + int uniformbufferobject; + int framebufferobject; + int defaultframebufferobject; // deal with platforms that use a non-zero default fbo qboolean pointer_color_enabled; int pointer_vertex_components; @@ -153,19 +227,8 @@ typedef struct gl_state_s void *preparevertices_tempdata; size_t preparevertices_tempdatamaxsize; - r_meshbuffer_t *preparevertices_dynamicvertexbuffer; - r_vertexposition_t *preparevertices_vertexposition; - r_vertexgeneric_t *preparevertices_vertexgeneric; - r_vertexmesh_t *preparevertices_vertexmesh; int preparevertices_numvertices; - r_meshbuffer_t *draw_dynamicindexbuffer; - - qboolean usevbo_staticvertex; - qboolean usevbo_staticindex; - qboolean usevbo_dynamicvertex; - qboolean usevbo_dynamicindex; - memexpandablearray_t meshbufferarray; qboolean active; @@ -234,7 +297,7 @@ unsigned short polygonelement3s[(POLYGONELEMENTS_MAXPOINTS-2)*3]; int quadelement3i[QUADELEMENTS_MAXQUADS*6]; unsigned short quadelement3s[QUADELEMENTS_MAXQUADS*6]; -void GL_VBOStats_f(void) +static void GL_VBOStats_f(void) { GL_Mesh_ListVBOs(true); } @@ -245,10 +308,6 @@ static void gl_backend_start(void) { memset(&gl_state, 0, sizeof(gl_state)); - gl_state.usevbo_staticvertex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo; - gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && (gl_vbo.integer == 1 || gl_vbo.integer == 3)) || vid.forcevbo; - gl_state.usevbo_dynamicvertex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer) || vid.forcevbo; - gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicindex.integer) || vid.forcevbo; Mem_ExpandableArray_NewArray(&gl_state.meshbufferarray, r_main_mempool, sizeof(r_meshbuffer_t), 128); Con_DPrintf("OpenGL backend started.\n"); @@ -256,16 +315,31 @@ static void gl_backend_start(void) CHECKGLERROR GL_Backend_ResetState(); + + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + // fetch current fbo here (default fbo is not 0 on some GLES devices) + CHECKGLERROR + qglGetIntegerv(GL_FRAMEBUFFER_BINDING, &gl_state.defaultframebufferobject);CHECKGLERROR + break; + } } static void gl_backend_shutdown(void) { Con_DPrint("OpenGL Backend shutting down\n"); + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + break; + } + if (gl_state.preparevertices_tempdata) Mem_Free(gl_state.preparevertices_tempdata); - if (gl_state.preparevertices_dynamicvertexbuffer) - R_Mesh_DestroyMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer); Mem_ExpandableArray_FreeArray(&gl_state.meshbufferarray); @@ -276,6 +350,41 @@ static void gl_backend_newmap(void) { } +static void gl_backend_devicelost(void) +{ + int i, endindex; + r_meshbuffer_t *buffer; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + break; + } + endindex = (int)Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray); + for (i = 0;i < endindex;i++) + { + buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i); + if (!buffer || !buffer->isdynamic) + continue; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + break; + } + } +} + +static void gl_backend_devicerestored(void) +{ + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + break; + } +} + void gl_backend_init(void) { int i; @@ -299,7 +408,7 @@ void gl_backend_init(void) for (i = 0;i < (POLYGONELEMENTS_MAXPOINTS - 2)*3;i++) polygonelement3i[i] = polygonelement3s[i]; - for (i = 0;i < QUADELEMENTS_MAXQUADS*3;i++) + for (i = 0;i < QUADELEMENTS_MAXQUADS*6;i++) quadelement3i[i] = quadelement3s[i]; Cvar_RegisterVariable(&r_render); @@ -308,20 +417,12 @@ void gl_backend_init(void) Cvar_RegisterVariable(&gl_polyblend); Cvar_RegisterVariable(&v_flipped); Cvar_RegisterVariable(&gl_dither); - Cvar_RegisterVariable(&gl_vbo); - Cvar_RegisterVariable(&gl_vbo_dynamicvertex); - Cvar_RegisterVariable(&gl_vbo_dynamicindex); Cvar_RegisterVariable(&gl_paranoid); Cvar_RegisterVariable(&gl_printcheckerror); - Cvar_RegisterVariable(&gl_mesh_drawrangeelements); - Cvar_RegisterVariable(&gl_mesh_testmanualfeeding); - Cvar_RegisterVariable(&gl_mesh_prefer_short_elements); - Cvar_RegisterVariable(&gl_mesh_separatearrays); - Cmd_AddCommand("gl_vbostats", GL_VBOStats_f, "prints a list of all buffer objects (vertex data and triangle elements) and total video memory used by them"); - R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap); + R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap, gl_backend_devicelost, gl_backend_devicerestored); } void GL_SetMirrorState(qboolean state); @@ -334,10 +435,167 @@ void R_Viewport_TransformToScreen(const r_viewport_t *v, const vec4_t in, vec4_t Matrix4x4_Transform4 (&v->projectmatrix, temp, out); iw = 1.0f / out[3]; out[0] = v->x + (out[0] * iw + 1.0f) * v->width * 0.5f; - out[1] = v->y + v->height - (out[1] * iw + 1.0f) * v->height * 0.5f; + + // for an odd reason, inverting this is wrong for R_Shadow_ScissorForBBox (we then get badly scissored lights) + //out[1] = v->y + v->height - (out[1] * iw + 1.0f) * v->height * 0.5f; + out[1] = v->y + (out[1] * iw + 1.0f) * v->height * 0.5f; + out[2] = v->z + (out[2] * iw + 1.0f) * v->depth * 0.5f; } +void GL_Finish(void) +{ + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglFinish();CHECKGLERROR + break; + } +} + +static int bboxedges[12][2] = +{ + // top + {0, 1}, // +X + {0, 2}, // +Y + {1, 3}, // Y, +X + {2, 3}, // X, +Y + // bottom + {4, 5}, // +X + {4, 6}, // +Y + {5, 7}, // Y, +X + {6, 7}, // X, +Y + // verticals + {0, 4}, // +Z + {1, 5}, // X, +Z + {2, 6}, // Y, +Z + {3, 7}, // XY, +Z +}; + +qboolean R_ScissorForBBox(const float *mins, const float *maxs, int *scissor) +{ + int i, ix1, iy1, ix2, iy2; + float x1, y1, x2, y2; + vec4_t v, v2; + float vertex[20][3]; + int j, k; + vec4_t plane4f; + int numvertices; + float corner[8][4]; + float dist[8]; + int sign[8]; + float f; + + scissor[0] = r_refdef.view.viewport.x; + scissor[1] = r_refdef.view.viewport.y; + scissor[2] = r_refdef.view.viewport.width; + scissor[3] = r_refdef.view.viewport.height; + + // if view is inside the box, just say yes it's visible + if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs)) + return false; + + // transform all corners that are infront of the nearclip plane + VectorNegate(r_refdef.view.frustum[4].normal, plane4f); + plane4f[3] = r_refdef.view.frustum[4].dist; + numvertices = 0; + for (i = 0;i < 8;i++) + { + Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1); + dist[i] = DotProduct4(corner[i], plane4f); + sign[i] = dist[i] > 0; + if (!sign[i]) + { + VectorCopy(corner[i], vertex[numvertices]); + numvertices++; + } + } + // if some points are behind the nearclip, add clipped edge points to make + // sure that the scissor boundary is complete + if (numvertices > 0 && numvertices < 8) + { + // add clipped edge points + for (i = 0;i < 12;i++) + { + j = bboxedges[i][0]; + k = bboxedges[i][1]; + if (sign[j] != sign[k]) + { + f = dist[j] / (dist[j] - dist[k]); + VectorLerp(corner[j], f, corner[k], vertex[numvertices]); + numvertices++; + } + } + } + + // if we have no points to check, it is behind the view plane + if (!numvertices) + return true; + + // if we have some points to transform, check what screen area is covered + x1 = y1 = x2 = y2 = 0; + v[3] = 1.0f; + //Con_Printf("%i vertices to transform...\n", numvertices); + for (i = 0;i < numvertices;i++) + { + VectorCopy(vertex[i], v); + R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); + if (i) + { + if (x1 > v2[0]) x1 = v2[0]; + if (x2 < v2[0]) x2 = v2[0]; + if (y1 > v2[1]) y1 = v2[1]; + if (y2 < v2[1]) y2 = v2[1]; + } + else + { + x1 = x2 = v2[0]; + y1 = y2 = v2[1]; + } + } + + // now convert the scissor rectangle to integer screen coordinates + ix1 = (int)(x1 - 1.0f); + //iy1 = vid.height - (int)(y2 - 1.0f); + //iy1 = r_refdef.view.viewport.width + 2 * r_refdef.view.viewport.x - (int)(y2 - 1.0f); + iy1 = (int)(y1 - 1.0f); + ix2 = (int)(x2 + 1.0f); + //iy2 = vid.height - (int)(y1 + 1.0f); + //iy2 = r_refdef.view.viewport.height + 2 * r_refdef.view.viewport.y - (int)(y1 + 1.0f); + iy2 = (int)(y2 + 1.0f); + //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2); + + // clamp it to the screen + if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x; + if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y; + if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width; + if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height; + + // if it is inside out, it's not visible + if (ix2 <= ix1 || iy2 <= iy1) + return true; + + // the light area is visible, set up the scissor rectangle + scissor[0] = ix1; + scissor[1] = iy1; + scissor[2] = ix2 - ix1; + scissor[3] = iy2 - iy1; + + // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + break; + } + + return false; +} + + static void R_Viewport_ApplyNearClipPlaneFloatGL(const r_viewport_t *v, float *m, float normalx, float normaly, float normalz, float dist) { float q[4]; @@ -349,24 +607,11 @@ static void R_Viewport_ApplyNearClipPlaneFloatGL(const r_viewport_t *v, float *m VectorSet(normal, normalx, normaly, normalz); Matrix4x4_Transform3x3(&v->viewmatrix, normal, clipPlane); - VectorScale(normal, dist, v3); + VectorScale(normal, -dist, v3); Matrix4x4_Transform(&v->viewmatrix, v3, v4); // FIXME: LordHavoc: I think this can be done more efficiently somehow but I can't remember the technique clipPlane[3] = -DotProduct(v4, clipPlane); -#if 0 -{ - // testing code for comparing results - float clipPlane2[4]; - VectorCopy4(clipPlane, clipPlane2); - R_EntityMatrix(&identitymatrix); - VectorSet(q, normal[0], normal[1], normal[2], -dist); - qglClipPlane(GL_CLIP_PLANE0, q); - qglGetClipPlane(GL_CLIP_PLANE0, q); - VectorCopy4(q, clipPlane); -} -#endif - // Calculate the clip-space corner point opposite the clipping plane // as (sgn(clipPlane.x), sgn(clipPlane.y), 1, 1) and // transform it into camera space by multiplying it @@ -407,6 +652,12 @@ void R_Viewport_InitOrtho(r_viewport_t *v, const matrix4x4_t *cameramatrix, int m[13] = - (top + bottom)/(top - bottom); m[14] = - (zFar + zNear)/(zFar - zNear); m[15] = 1; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + break; + } v->screentodepth[0] = -farclip / (farclip - nearclip); v->screentodepth[1] = farclip * nearclip / (farclip - nearclip); @@ -428,14 +679,53 @@ void R_Viewport_InitOrtho(r_viewport_t *v, const matrix4x4_t *cameramatrix, int #endif } -void R_Viewport_InitPerspective(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float frustumx, float frustumy, float nearclip, float farclip, const float *nearplane) +void R_Viewport_InitOrtho3D(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float frustumx, float frustumy, float nearclip, float farclip, const float *nearplane) { matrix4x4_t tempmatrix, basematrix; float m[16]; memset(v, 0, sizeof(*v)); + v->type = R_VIEWPORTTYPE_PERSPECTIVE; + v->cameramatrix = *cameramatrix; + v->x = x; + v->y = y; + v->z = 0; + v->width = width; + v->height = height; + v->depth = 1; + memset(m, 0, sizeof(m)); + m[0] = 1.0 / frustumx; + m[5] = 1.0 / frustumy; + m[10] = -2 / (farclip - nearclip); + m[14] = -(farclip + nearclip) / (farclip - nearclip); + m[15] = 1; + v->screentodepth[0] = -farclip / (farclip - nearclip); + v->screentodepth[1] = farclip * nearclip / (farclip - nearclip); + + Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix); + Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0); + Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1); + Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix); + + if (nearplane) + R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]); + if(v_flipped.integer) - frustumx = -frustumx; + { + m[0] = -m[0]; + m[4] = -m[4]; + m[8] = -m[8]; + m[12] = -m[12]; + } + + Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m); +} + +void R_Viewport_InitPerspective(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float frustumx, float frustumy, float nearclip, float farclip, const float *nearplane) +{ + matrix4x4_t tempmatrix, basematrix; + float m[16]; + memset(v, 0, sizeof(*v)); v->type = R_VIEWPORTTYPE_PERSPECTIVE; v->cameramatrix = *cameramatrix; @@ -462,6 +752,14 @@ void R_Viewport_InitPerspective(r_viewport_t *v, const matrix4x4_t *cameramatrix if (nearplane) R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]); + if(v_flipped.integer) + { + m[0] = -m[0]; + m[4] = -m[4]; + m[8] = -m[8]; + m[12] = -m[12]; + } + Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m); } @@ -472,9 +770,6 @@ void R_Viewport_InitPerspectiveInfinite(r_viewport_t *v, const matrix4x4_t *came float m[16]; memset(v, 0, sizeof(*v)); - if(v_flipped.integer) - frustumx = -frustumx; - v->type = R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP; v->cameramatrix = *cameramatrix; v->x = x; @@ -500,6 +795,14 @@ void R_Viewport_InitPerspectiveInfinite(r_viewport_t *v, const matrix4x4_t *came if (nearplane) R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]); + if(v_flipped.integer) + { + m[0] = -m[0]; + m[4] = -m[4]; + m[8] = -m[8]; + m[12] = -m[12]; + } + Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m); } @@ -601,7 +904,7 @@ void R_Viewport_InitCubeSideView(r_viewport_t *v, const matrix4x4_t *cameramatri m[14] = -2 * nearclip * farclip / (farclip - nearclip); Matrix4x4_FromArrayFloatGL(&basematrix, cubeviewmatrix[side]); - Matrix4x4_Invert_Simple(&tempmatrix, &v->cameramatrix); + Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix); Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix); if (nearplane) @@ -610,15 +913,15 @@ void R_Viewport_InitCubeSideView(r_viewport_t *v, const matrix4x4_t *cameramatri Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m); } -void R_Viewport_InitRectSideView(r_viewport_t *v, const matrix4x4_t *cameramatrix, int side, int size, int border, float nearclip, float farclip, const float *nearplane) +void R_Viewport_InitRectSideView(r_viewport_t *v, const matrix4x4_t *cameramatrix, int side, int size, int border, float nearclip, float farclip, const float *nearplane, int offsetx, int offsety) { matrix4x4_t tempmatrix, basematrix; float m[16]; memset(v, 0, sizeof(*v)); v->type = R_VIEWPORTTYPE_PERSPECTIVECUBESIDE; v->cameramatrix = *cameramatrix; - v->x = (side & 1) * size; - v->y = (side >> 1) * size; + v->x = offsetx + (side & 1) * size; + v->y = offsety + (side >> 1) * size; v->width = size; v->height = size; v->depth = 1; @@ -629,7 +932,7 @@ void R_Viewport_InitRectSideView(r_viewport_t *v, const matrix4x4_t *cameramatri m[14] = -2 * nearclip * farclip / (farclip - nearclip); Matrix4x4_FromArrayFloatGL(&basematrix, rectviewmatrix[side]); - Matrix4x4_Invert_Simple(&tempmatrix, &v->cameramatrix); + Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix); Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix); if (nearplane) @@ -640,12 +943,8 @@ void R_Viewport_InitRectSideView(r_viewport_t *v, const matrix4x4_t *cameramatri void R_SetViewport(const r_viewport_t *v) { - float m[16]; gl_viewport = *v; - CHECKGLERROR - qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR - // FIXME: v_flipped_state is evil, this probably breaks somewhere GL_SetMirrorState(v_flipped.integer && (v->type == R_VIEWPORTTYPE_PERSPECTIVE || v->type == R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP)); @@ -655,16 +954,10 @@ void R_SetViewport(const r_viewport_t *v) switch(vid.renderpath) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: -// break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - // Load the projection matrix into OpenGL - qglMatrixMode(GL_PROJECTION);CHECKGLERROR - Matrix4x4_ToArrayFloatGL(&gl_projectionmatrix, m); - qglLoadMatrixf(m);CHECKGLERROR - qglMatrixMode(GL_MODELVIEW);CHECKGLERROR + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR break; } @@ -684,8 +977,7 @@ static void GL_BindVBO(int bufferobject) { gl_state.vertexbufferobject = bufferobject; CHECKGLERROR - qglBindBufferARB(GL_ARRAY_BUFFER_ARB, bufferobject); - CHECKGLERROR + qglBindBuffer(GL_ARRAY_BUFFER, bufferobject);CHECKGLERROR } } @@ -695,8 +987,141 @@ static void GL_BindEBO(int bufferobject) { gl_state.elementbufferobject = bufferobject; CHECKGLERROR - qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, bufferobject); + qglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferobject);CHECKGLERROR + } +} + +static void GL_BindUBO(int bufferobject) +{ + if (gl_state.uniformbufferobject != bufferobject) + { + gl_state.uniformbufferobject = bufferobject; +#ifdef GL_UNIFORM_BUFFER + CHECKGLERROR + qglBindBuffer(GL_UNIFORM_BUFFER, bufferobject);CHECKGLERROR +#endif + } +} + +static const GLuint drawbuffers[4] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3}; +int R_Mesh_CreateFramebufferObject(rtexture_t *depthtexture, rtexture_t *colortexture, rtexture_t *colortexture2, rtexture_t *colortexture3, rtexture_t *colortexture4) +{ + int temp; + GLuint status; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: CHECKGLERROR + qglGenFramebuffers(1, (GLuint*)&temp);CHECKGLERROR + R_Mesh_SetRenderTargets(temp, NULL, NULL, NULL, NULL, NULL); + // GL_ARB_framebuffer_object (GL3-class hardware) - depth stencil attachment +#ifdef USE_GLES2 + // FIXME: separate stencil attachment on GLES + if (depthtexture && depthtexture->texnum ) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR + if (depthtexture && depthtexture->renderbuffernum ) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR +#else + if (depthtexture && depthtexture->texnum ) + { + qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR + if (depthtexture->glisdepthstencil) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR + } + if (depthtexture && depthtexture->renderbuffernum ) + { + qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR + if (depthtexture->glisdepthstencil) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR + } +#endif + if (colortexture && colortexture->texnum ) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , colortexture->gltexturetypeenum , colortexture->texnum , 0);CHECKGLERROR + if (colortexture2 && colortexture2->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , colortexture2->gltexturetypeenum, colortexture2->texnum, 0);CHECKGLERROR + if (colortexture3 && colortexture3->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , colortexture3->gltexturetypeenum, colortexture3->texnum, 0);CHECKGLERROR + if (colortexture4 && colortexture4->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , colortexture4->gltexturetypeenum, colortexture4->texnum, 0);CHECKGLERROR + if (colortexture && colortexture->renderbuffernum ) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER, colortexture->renderbuffernum );CHECKGLERROR + if (colortexture2 && colortexture2->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , GL_RENDERBUFFER, colortexture2->renderbuffernum);CHECKGLERROR + if (colortexture3 && colortexture3->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , GL_RENDERBUFFER, colortexture3->renderbuffernum);CHECKGLERROR + if (colortexture4 && colortexture4->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , GL_RENDERBUFFER, colortexture4->renderbuffernum);CHECKGLERROR + +#ifndef USE_GLES2 + if (colortexture4 && qglDrawBuffersARB) + { + qglDrawBuffersARB(4, drawbuffers);CHECKGLERROR + qglReadBuffer(GL_NONE);CHECKGLERROR + } + else if (colortexture3 && qglDrawBuffersARB) + { + qglDrawBuffersARB(3, drawbuffers);CHECKGLERROR + qglReadBuffer(GL_NONE);CHECKGLERROR + } + else if (colortexture2 && qglDrawBuffersARB) + { + qglDrawBuffersARB(2, drawbuffers);CHECKGLERROR + qglReadBuffer(GL_NONE);CHECKGLERROR + } + else if (colortexture && qglDrawBuffer) + { + qglDrawBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR + qglReadBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR + } + else if (qglDrawBuffer) + { + qglDrawBuffer(GL_NONE);CHECKGLERROR + qglReadBuffer(GL_NONE);CHECKGLERROR + } +#endif + status = qglCheckFramebufferStatus(GL_FRAMEBUFFER);CHECKGLERROR + if (status != GL_FRAMEBUFFER_COMPLETE) + { + Con_Printf("R_Mesh_CreateFramebufferObject: glCheckFramebufferStatus returned %i\n", status); + gl_state.framebufferobject = 0; // GL unbinds it for us + qglDeleteFramebuffers(1, (GLuint*)&temp);CHECKGLERROR + temp = 0; + } + return temp; + } + return 0; +} + +void R_Mesh_DestroyFramebufferObject(int fbo) +{ + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + if (fbo) + { + // GL clears the binding if we delete something bound + if (gl_state.framebufferobject == fbo) + gl_state.framebufferobject = 0; + qglDeleteFramebuffers(1, (GLuint*)&fbo);CHECKGLERROR + } + break; + } +} + +void R_Mesh_SetRenderTargets(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, rtexture_t *colortexture2, rtexture_t *colortexture3, rtexture_t *colortexture4) +{ + unsigned int i; + unsigned int j; + rtexture_t *textures[5]; + Vector4Set(textures, colortexture, colortexture2, colortexture3, colortexture4); + textures[4] = depthtexture; + // unbind any matching textures immediately, otherwise D3D will complain about a bound texture being used as a render target + for (j = 0;j < 5;j++) + if (textures[j]) + for (i = 0;i < vid.teximageunits;i++) + if (gl_state.units[i].texture == textures[j]) + R_Mesh_TexBind(i, NULL); + // set up framebuffer object or render targets for the active rendering API + switch (vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + if (gl_state.framebufferobject != fbo) + { + gl_state.framebufferobject = fbo; + qglBindFramebuffer(GL_FRAMEBUFFER, gl_state.framebufferobject ? gl_state.framebufferobject : gl_state.defaultframebufferobject);CHECKGLERROR + } + break; } } @@ -706,6 +1131,9 @@ static void GL_Backend_ResetState(void) gl_state.active = true; gl_state.depthtest = true; gl_state.alphatest = false; + gl_state.alphafunc = GL_GEQUAL; + gl_state.alphafuncvalue = 0.5f; + gl_state.alphatocoverage = false; gl_state.blendfunc1 = GL_ONE; gl_state.blendfunc2 = GL_ZERO; gl_state.blend = false; @@ -714,109 +1142,46 @@ static void GL_Backend_ResetState(void) gl_state.color4f[0] = gl_state.color4f[1] = gl_state.color4f[2] = gl_state.color4f[3] = 1; gl_state.lockrange_first = 0; gl_state.lockrange_count = 0; - gl_state.cullface = v_flipped_state ? GL_BACK : GL_FRONT; // quake is backwards, this culls back faces - gl_state.cullfaceenable = true; + gl_state.cullface = GL_FRONT; + gl_state.cullfaceenable = false; gl_state.polygonoffset[0] = 0; gl_state.polygonoffset[1] = 0; + gl_state.framebufferobject = 0; + gl_state.depthfunc = GL_LEQUAL; - CHECKGLERROR - - qglColorMask(1, 1, 1, 1); - qglAlphaFunc(GL_GEQUAL, 0.5);CHECKGLERROR - qglDisable(GL_ALPHA_TEST);CHECKGLERROR - qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR - qglDisable(GL_BLEND);CHECKGLERROR - qglCullFace(gl_state.cullface);CHECKGLERROR - qglEnable(GL_CULL_FACE);CHECKGLERROR - qglDepthFunc(GL_LEQUAL);CHECKGLERROR - qglEnable(GL_DEPTH_TEST);CHECKGLERROR - qglDepthMask(gl_state.depthmask);CHECKGLERROR - qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]); - - if (vid.support.arb_vertex_buffer_object) - { - qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); - qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); - } - - if (vid.support.ext_framebuffer_object) - { - qglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); - qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); - } - - qglVertexPointer(3, GL_FLOAT, sizeof(float[3]), NULL);CHECKGLERROR - qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR - - qglColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL);CHECKGLERROR - qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR - - GL_Color(0, 0, 0, 0); - GL_Color(1, 1, 1, 1); - - gl_state.unit = MAX_TEXTUREUNITS; - gl_state.clientunit = MAX_TEXTUREUNITS; switch(vid.renderpath) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglColorMask(1, 1, 1, 1);CHECKGLERROR + qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR + qglDisable(GL_BLEND);CHECKGLERROR + qglCullFace(gl_state.cullface);CHECKGLERROR + qglDisable(GL_CULL_FACE);CHECKGLERROR + qglDepthFunc(GL_LEQUAL);CHECKGLERROR + qglEnable(GL_DEPTH_TEST);CHECKGLERROR + qglDepthMask(gl_state.depthmask);CHECKGLERROR + qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]); + qglBindBuffer(GL_ARRAY_BUFFER, 0); + qglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + qglBindFramebuffer(GL_FRAMEBUFFER, gl_state.defaultframebufferobject); + qglEnableVertexAttribArray(GLSLATTRIB_POSITION); + qglDisableVertexAttribArray(GLSLATTRIB_COLOR); + qglVertexAttrib4f(GLSLATTRIB_COLOR, 1, 1, 1, 1); + gl_state.unit = MAX_TEXTUREUNITS; + gl_state.clientunit = MAX_TEXTUREUNITS; for (i = 0;i < vid.teximageunits;i++) { GL_ActiveTexture(i); qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR - if (vid.support.ext_texture_3d) - { - qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR - } - if (vid.support.arb_texture_cube_map) - { - qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);CHECKGLERROR - } - if (vid.support.arb_texture_rectangle) - { - qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);CHECKGLERROR - } + qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR + qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHECKGLERROR } - for (i = 0;i < vid.texarrayunits;i++) { - GL_ClientActiveTexture(i); - GL_BindVBO(0); - qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR - qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR - } - CHECKGLERROR - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - for (i = 0;i < vid.texunits;i++) - { - GL_ActiveTexture(i); - GL_ClientActiveTexture(i); - qglDisable(GL_TEXTURE_2D);CHECKGLERROR - qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR - if (vid.support.ext_texture_3d) - { - qglDisable(GL_TEXTURE_3D);CHECKGLERROR - qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR - } - if (vid.support.arb_texture_cube_map) - { - qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR - qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);CHECKGLERROR - } - if (vid.support.arb_texture_rectangle) - { - qglDisable(GL_TEXTURE_RECTANGLE_ARB);CHECKGLERROR - qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);CHECKGLERROR - } GL_BindVBO(0); - qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR - qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR - qglMatrixMode(GL_TEXTURE);CHECKGLERROR - qglLoadIdentity();CHECKGLERROR - qglMatrixMode(GL_MODELVIEW);CHECKGLERROR - qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR + qglDisableVertexAttribArray(i+GLSLATTRIB_TEXCOORD0);CHECKGLERROR } CHECKGLERROR break; @@ -828,25 +1193,13 @@ void GL_ActiveTexture(unsigned int num) if (gl_state.unit != num) { gl_state.unit = num; - if (qglActiveTexture) - { - CHECKGLERROR - qglActiveTexture(GL_TEXTURE0_ARB + gl_state.unit); - CHECKGLERROR - } - } -} - -void GL_ClientActiveTexture(unsigned int num) -{ - if (gl_state.clientunit != num) - { - gl_state.clientunit = num; - if (qglActiveTexture) + switch(vid.renderpath) { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: CHECKGLERROR - qglClientActiveTexture(GL_TEXTURE0_ARB + gl_state.clientunit); - CHECKGLERROR + qglActiveTexture(GL_TEXTURE0 + gl_state.unit);CHECKGLERROR + break; } } } @@ -855,34 +1208,36 @@ void GL_BlendFunc(int blendfunc1, int blendfunc2) { if (gl_state.blendfunc1 != blendfunc1 || gl_state.blendfunc2 != blendfunc2) { - CHECKGLERROR - qglBlendFunc(gl_state.blendfunc1 = blendfunc1, gl_state.blendfunc2 = blendfunc2);CHECKGLERROR - if (gl_state.blendfunc2 == GL_ZERO) + qboolean blendenable; + gl_state.blendfunc1 = blendfunc1; + gl_state.blendfunc2 = blendfunc2; + blendenable = (gl_state.blendfunc1 != GL_ONE || gl_state.blendfunc2 != GL_ZERO); + switch(vid.renderpath) { - if (gl_state.blendfunc1 == GL_ONE) + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if (qglBlendFuncSeparate) { - if (gl_state.blend) - { - gl_state.blend = 0; - qglDisable(GL_BLEND);CHECKGLERROR - } + qglBlendFuncSeparate(gl_state.blendfunc1, gl_state.blendfunc2, GL_ZERO, GL_ONE);CHECKGLERROR // ELUAN: Adreno 225 (and others) compositing workaround } else { + qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR + } + if (gl_state.blend != blendenable) + { + gl_state.blend = blendenable; if (!gl_state.blend) { - gl_state.blend = 1; - qglEnable(GL_BLEND);CHECKGLERROR + qglDisable(GL_BLEND);CHECKGLERROR + } + else + { + qglEnable(GL_BLEND);CHECKGLERROR } } - } - else - { - if (!gl_state.blend) - { - gl_state.blend = 1; - qglEnable(GL_BLEND);CHECKGLERROR - } + break; } } } @@ -891,8 +1246,15 @@ void GL_DepthMask(int state) { if (gl_state.depthmask != state) { - CHECKGLERROR - qglDepthMask(gl_state.depthmask = state);CHECKGLERROR + gl_state.depthmask = state; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglDepthMask(gl_state.depthmask);CHECKGLERROR + break; + } } } @@ -901,14 +1263,36 @@ void GL_DepthTest(int state) if (gl_state.depthtest != state) { gl_state.depthtest = state; - CHECKGLERROR - if (gl_state.depthtest) + switch(vid.renderpath) { - qglEnable(GL_DEPTH_TEST);CHECKGLERROR + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if (gl_state.depthtest) + { + qglEnable(GL_DEPTH_TEST);CHECKGLERROR + } + else + { + qglDisable(GL_DEPTH_TEST);CHECKGLERROR + } + break; } - else + } +} + +void GL_DepthFunc(int state) +{ + if (gl_state.depthfunc != state) + { + gl_state.depthfunc = state; + switch(vid.renderpath) { - qglDisable(GL_DEPTH_TEST);CHECKGLERROR + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglDepthFunc(gl_state.depthfunc);CHECKGLERROR + break; } } } @@ -919,7 +1303,41 @@ void GL_DepthRange(float nearfrac, float farfrac) { gl_state.depthrange[0] = nearfrac; gl_state.depthrange[1] = farfrac; - qglDepthRange(nearfrac, farfrac); + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR +#ifdef USE_GLES2 + qglDepthRangef(gl_state.depthrange[0], gl_state.depthrange[1]);CHECKGLERROR +#else + qglDepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);CHECKGLERROR +#endif + break; + } + } +} + +void R_SetStencil(qboolean enable, int writemask, int fail, int zfail, int zpass, int compare, int comparereference, int comparemask) +{ + switch (vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if (enable) + { + qglEnable(GL_STENCIL_TEST);CHECKGLERROR + } + else + { + qglDisable(GL_STENCIL_TEST);CHECKGLERROR + } + qglStencilMask(writemask);CHECKGLERROR + qglStencilOp(fail, zfail, zpass);CHECKGLERROR + qglStencilFunc(compare, comparereference, comparemask);CHECKGLERROR + CHECKGLERROR + break; } } @@ -929,27 +1347,41 @@ void GL_PolygonOffset(float planeoffset, float depthoffset) { gl_state.polygonoffset[0] = planeoffset; gl_state.polygonoffset[1] = depthoffset; - qglPolygonOffset(planeoffset, depthoffset); + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);CHECKGLERROR + break; + } } } void GL_SetMirrorState(qboolean state) { - if(!state != !v_flipped_state) + if (v_flipped_state != state) { - // change cull face mode! - if(gl_state.cullface == GL_BACK) - qglCullFace((gl_state.cullface = GL_FRONT)); - else if(gl_state.cullface == GL_FRONT) - qglCullFace((gl_state.cullface = GL_BACK)); + v_flipped_state = state; + if (gl_state.cullface == GL_BACK) + gl_state.cullface = GL_FRONT; + else if (gl_state.cullface == GL_FRONT) + gl_state.cullface = GL_BACK; + else + return; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglCullFace(gl_state.cullface);CHECKGLERROR + break; + } } - v_flipped_state = state; } void GL_CullFace(int state) { - CHECKGLERROR - if(v_flipped_state) { if(state == GL_FRONT) @@ -958,54 +1390,81 @@ void GL_CullFace(int state) state = GL_FRONT; } - if (state != GL_NONE) + switch(vid.renderpath) { - if (!gl_state.cullfaceenable) - { - gl_state.cullfaceenable = true; - qglEnable(GL_CULL_FACE);CHECKGLERROR - } - if (gl_state.cullface != state) + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + + if (state != GL_NONE) { - gl_state.cullface = state; - qglCullFace(gl_state.cullface);CHECKGLERROR + if (!gl_state.cullfaceenable) + { + gl_state.cullfaceenable = true; + qglEnable(GL_CULL_FACE);CHECKGLERROR + } + if (gl_state.cullface != state) + { + gl_state.cullface = state; + qglCullFace(gl_state.cullface);CHECKGLERROR + } } - } - else - { - if (gl_state.cullfaceenable) + else { - gl_state.cullfaceenable = false; - qglDisable(GL_CULL_FACE);CHECKGLERROR + if (gl_state.cullfaceenable) + { + gl_state.cullfaceenable = false; + qglDisable(GL_CULL_FACE);CHECKGLERROR + } } + break; } } -void GL_AlphaTest(int state) +void GL_AlphaToCoverage(qboolean state) { - if (gl_state.alphatest != state) + if (gl_state.alphatocoverage != state) { - gl_state.alphatest = state; - CHECKGLERROR - if (gl_state.alphatest) - { - qglEnable(GL_ALPHA_TEST);CHECKGLERROR - } - else + gl_state.alphatocoverage = state; + switch(vid.renderpath) { - qglDisable(GL_ALPHA_TEST);CHECKGLERROR + case RENDERPATH_GLES2: + break; + case RENDERPATH_GL32: +#ifdef GL_SAMPLE_ALPHA_TO_COVERAGE_ARB + // alpha to coverage turns the alpha value of the pixel into 0%, 25%, 50%, 75% or 100% by masking the multisample fragments accordingly + CHECKGLERROR + if (gl_state.alphatocoverage) + { + qglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR +// qglEnable(GL_MULTISAMPLE_ARB);CHECKGLERROR + } + else + { + qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR +// qglDisable(GL_MULTISAMPLE_ARB);CHECKGLERROR + } +#endif + break; } } } void GL_ColorMask(int r, int g, int b, int a) { - int state = r*8 + g*4 + b*2 + a*1; + // NOTE: this matches D3DCOLORWRITEENABLE_RED, GREEN, BLUE, ALPHA + int state = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0) | (a ? 8 : 0); if (gl_state.colormask != state) { gl_state.colormask = state; - CHECKGLERROR - qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR + break; + } } } @@ -1017,47 +1476,125 @@ void GL_Color(float cr, float cg, float cb, float ca) gl_state.color4f[1] = cg; gl_state.color4f[2] = cb; gl_state.color4f[3] = ca; - CHECKGLERROR - qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]); - CHECKGLERROR + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + qglVertexAttrib4f(GLSLATTRIB_COLOR, cr, cg, cb, ca);CHECKGLERROR + break; + } } } void GL_Scissor (int x, int y, int width, int height) { - CHECKGLERROR - qglScissor(x, y,width,height); - CHECKGLERROR + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + qglScissor(x, y,width,height);CHECKGLERROR + break; + } } void GL_ScissorTest(int state) { - if(gl_state.scissortest == state) - return; + if (gl_state.scissortest != state) + { + gl_state.scissortest = state; + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if(gl_state.scissortest) + qglEnable(GL_SCISSOR_TEST); + else + qglDisable(GL_SCISSOR_TEST); + CHECKGLERROR + break; + } + } +} - CHECKGLERROR - if((gl_state.scissortest = state)) - qglEnable(GL_SCISSOR_TEST); - else - qglDisable(GL_SCISSOR_TEST); - CHECKGLERROR +void GL_Clear(int mask, const float *colorvalue, float depthvalue, int stencilvalue) +{ + // opaque black - if you want transparent black, you'll need to pass in a colorvalue + static const float blackcolor[4] = {0.0f, 0.0f, 0.0f, 1.0f}; + // prevent warnings when trying to clear a buffer that does not exist + if (!colorvalue) + colorvalue = blackcolor; + if (!vid.stencil) + { + mask &= ~GL_STENCIL_BUFFER_BIT; + stencilvalue = 0; + } + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if (mask & GL_COLOR_BUFFER_BIT) + { + qglClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);CHECKGLERROR + } + if (mask & GL_DEPTH_BUFFER_BIT) + { +#ifdef USE_GLES2 + qglClearDepthf(depthvalue);CHECKGLERROR +#else + qglClearDepth(depthvalue);CHECKGLERROR +#endif + } + if (mask & GL_STENCIL_BUFFER_BIT) + { + qglClearStencil(stencilvalue);CHECKGLERROR + } + qglClear(mask);CHECKGLERROR + break; + } } -void GL_Clear(int mask) +void GL_ReadPixelsBGRA(int x, int y, int width, int height, unsigned char *outpixels) { - CHECKGLERROR - qglClear(mask);CHECKGLERROR + switch(vid.renderpath) + { + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR +#ifndef GL_BGRA + { + int i; + int r; + // int g; + int b; + // int a; + qglReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, outpixels);CHECKGLERROR + for (i = 0;i < width * height * 4;i += 4) + { + r = outpixels[i+0]; + // g = outpixels[i+1]; + b = outpixels[i+2]; + // a = outpixels[i+3]; + outpixels[i+0] = b; + // outpixels[i+1] = g; + outpixels[i+2] = r; + // outpixels[i+3] = a; + } + } +#else + qglReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_BYTE, outpixels);CHECKGLERROR +#endif + break; + } } // called at beginning of frame void R_Mesh_Start(void) { BACKENDACTIVECHECK - CHECKGLERROR - gl_state.usevbo_staticvertex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo; - gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && (gl_vbo.integer == 1 || gl_vbo.integer == 3)) || vid.forcevbo; - gl_state.usevbo_dynamicvertex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer) || vid.forcevbo; - gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicindex.integer) || vid.forcevbo; + R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL); if (gl_printcheckerror.integer && !gl_paranoid.integer) { Con_Printf("WARNING: gl_printcheckerror is on but gl_paranoid is off, turning it on...\n"); @@ -1065,19 +1602,19 @@ void R_Mesh_Start(void) } } -qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, const char *shadertype, int numstrings, const char **strings) +static qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, const char *shadertype, int numstrings, const char **strings) { int shaderobject; int shadercompiled; char compilelog[MAX_INPUTLINE]; - shaderobject = qglCreateShaderObjectARB(shadertypeenum);CHECKGLERROR + shaderobject = qglCreateShader(shadertypeenum);CHECKGLERROR if (!shaderobject) return false; - qglShaderSourceARB(shaderobject, numstrings, strings, NULL);CHECKGLERROR - qglCompileShaderARB(shaderobject);CHECKGLERROR - qglGetObjectParameterivARB(shaderobject, GL_OBJECT_COMPILE_STATUS_ARB, &shadercompiled);CHECKGLERROR - qglGetInfoLogARB(shaderobject, sizeof(compilelog), NULL, compilelog);CHECKGLERROR - if (compilelog[0] && (strstr(compilelog, "error") || strstr(compilelog, "ERROR") || strstr(compilelog, "Error") || strstr(compilelog, "WARNING") || strstr(compilelog, "warning") || strstr(compilelog, "Warning"))) + qglShaderSource(shaderobject, numstrings, strings, NULL);CHECKGLERROR + qglCompileShader(shaderobject);CHECKGLERROR + qglGetShaderiv(shaderobject, GL_COMPILE_STATUS, &shadercompiled);CHECKGLERROR + qglGetShaderInfoLog(shaderobject, sizeof(compilelog), NULL, compilelog);CHECKGLERROR + if (compilelog[0] && ((strstr(compilelog, "error") || strstr(compilelog, "ERROR") || strstr(compilelog, "Error")) || ((strstr(compilelog, "WARNING") || strstr(compilelog, "warning") || strstr(compilelog, "Warning")) && developer.integer) || developer_extra.integer)) { int i, j, pretextlines = 0; for (i = 0;i < numstrings - 1;i++) @@ -1088,11 +1625,11 @@ qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, cons } if (!shadercompiled) { - qglDeleteObjectARB(shaderobject);CHECKGLERROR + qglDeleteShader(shaderobject);CHECKGLERROR return false; } - qglAttachObjectARB(programobject, shaderobject);CHECKGLERROR - qglDeleteObjectARB(shaderobject);CHECKGLERROR + qglAttachShader(programobject, shaderobject);CHECKGLERROR + qglDeleteShader(shaderobject);CHECKGLERROR return true; } @@ -1103,28 +1640,46 @@ unsigned int GL_Backend_CompileProgram(int vertexstrings_count, const char **ver char linklog[MAX_INPUTLINE]; CHECKGLERROR - programobject = qglCreateProgramObjectARB();CHECKGLERROR + programobject = qglCreateProgram();CHECKGLERROR if (!programobject) return 0; - if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER_ARB, "vertex", vertexstrings_count, vertexstrings_list)) + qglBindAttribLocation(programobject, GLSLATTRIB_POSITION , "Attrib_Position" ); + qglBindAttribLocation(programobject, GLSLATTRIB_COLOR , "Attrib_Color" ); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD0, "Attrib_TexCoord0"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD1, "Attrib_TexCoord1"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD2, "Attrib_TexCoord2"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD3, "Attrib_TexCoord3"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD4, "Attrib_TexCoord4"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD5, "Attrib_TexCoord5"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD6, "Attrib_SkeletalIndex"); + qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD7, "Attrib_SkeletalWeight"); +#ifndef USE_GLES2 + qglBindFragDataLocation(programobject, 0, "dp_FragColor"); +#endif + CHECKGLERROR + + if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER, "vertex", vertexstrings_count, vertexstrings_list)) goto cleanup; -#ifdef GL_GEOMETRY_SHADER_ARB - if (geometrystrings_count && !GL_Backend_CompileShader(programobject, GL_GEOMETRY_SHADER_ARB, "geometry", geometrystrings_count, geometrystrings_list)) +#if defined(GL_GEOMETRY_SHADER) && !defined(USE_GLES2) + if (geometrystrings_count && !GL_Backend_CompileShader(programobject, GL_GEOMETRY_SHADER, "geometry", geometrystrings_count, geometrystrings_list)) goto cleanup; #endif - if (fragmentstrings_count && !GL_Backend_CompileShader(programobject, GL_FRAGMENT_SHADER_ARB, "fragment", fragmentstrings_count, fragmentstrings_list)) + if (fragmentstrings_count && !GL_Backend_CompileShader(programobject, GL_FRAGMENT_SHADER, "fragment", fragmentstrings_count, fragmentstrings_list)) goto cleanup; - qglLinkProgramARB(programobject);CHECKGLERROR - qglGetObjectParameterivARB(programobject, GL_OBJECT_LINK_STATUS_ARB, &programlinked);CHECKGLERROR - qglGetInfoLogARB(programobject, sizeof(linklog), NULL, linklog);CHECKGLERROR + qglLinkProgram(programobject);CHECKGLERROR + qglGetProgramiv(programobject, GL_LINK_STATUS, &programlinked);CHECKGLERROR + qglGetProgramInfoLog(programobject, sizeof(linklog), NULL, linklog);CHECKGLERROR + if (linklog[0]) { - if (strstr(linklog, "error") || strstr(linklog, "ERROR") || strstr(linklog, "Error") || strstr(linklog, "WARNING") || strstr(linklog, "warning") || strstr(linklog, "Warning")) + + if (strstr(linklog, "error") || strstr(linklog, "ERROR") || strstr(linklog, "Error") || strstr(linklog, "WARNING") || strstr(linklog, "warning") || strstr(linklog, "Warning") || developer_extra.integer) Con_DPrintf("program link log:\n%s\n", linklog); + // software vertex shader is ok but software fragment shader is WAY // too slow, fail program if so. // NOTE: this string might be ATI specific, but that's ok because the @@ -1134,36 +1689,25 @@ unsigned int GL_Backend_CompileProgram(int vertexstrings_count, const char **ver if (strstr(linklog, "fragment shader will run in software")) programlinked = false; } + if (!programlinked) goto cleanup; + return programobject; cleanup: - qglDeleteObjectARB(programobject);CHECKGLERROR + qglDeleteProgram(programobject);CHECKGLERROR return 0; } void GL_Backend_FreeProgram(unsigned int prog) { CHECKGLERROR - qglDeleteObjectARB(prog); + qglDeleteProgram(prog); CHECKGLERROR } -void GL_Backend_RenumberElements(int *out, int count, const int *in, int offset) -{ - int i; - if (offset) - { - for (i = 0;i < count;i++) - *out++ = *in++ + offset; - } - else - memcpy(out, in, sizeof(*out) * count); -} - // renders triangles using vertices from the active arrays -int paranoidblah = 0; -void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const r_meshbuffer_t *element3i_indexbuffer, size_t element3i_bufferoffset, const unsigned short *element3s, const r_meshbuffer_t *element3s_indexbuffer, size_t element3s_bufferoffset) +void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const r_meshbuffer_t *element3i_indexbuffer, int element3i_bufferoffset, const unsigned short *element3s, const r_meshbuffer_t *element3s_indexbuffer, int element3s_bufferoffset) { unsigned int numelements = numtriangles * 3; int bufferobject3i; @@ -1176,18 +1720,6 @@ void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtri Con_DPrintf("R_Mesh_Draw(%d, %d, %d, %d, %8p, %8p, %8x, %8p, %8p, %8x);\n", firstvertex, numvertices, firsttriangle, numtriangles, (void *)element3i, (void *)element3i_indexbuffer, (int)element3i_bufferoffset, (void *)element3s, (void *)element3s_indexbuffer, (int)element3s_bufferoffset); return; } - if (gl_state.pointer_vertex_pointer == NULL) - { - Con_DPrintf("R_Mesh_Draw with no vertex pointer!\n"); - return; - } - if (!gl_mesh_prefer_short_elements.integer) - { - if (element3i) - element3s = NULL; - if (element3i_indexbuffer) - element3i_indexbuffer = NULL; - } // adjust the pointers for firsttriangle if (element3i) element3i += firsttriangle * 3; @@ -1197,85 +1729,27 @@ void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtri element3s += firsttriangle * 3; if (element3s_indexbuffer) element3s_bufferoffset += firsttriangle * 3 * sizeof(*element3s); - // check if the user specified to ignore static index buffers - if (!gl_state.usevbo_staticindex || (gl_vbo.integer == 3 && !vid.forcevbo && (element3i_bufferoffset || element3s_bufferoffset))) - { - element3i_indexbuffer = NULL; - element3s_indexbuffer = NULL; - } // upload a dynamic index buffer if needed if (element3s) { - if (!element3s_indexbuffer && gl_state.usevbo_dynamicindex) - { - if (gl_state.draw_dynamicindexbuffer) - R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3s, numelements * sizeof(*element3s)); - else - gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3s, numelements * sizeof(*element3s), "temporary", true, true); - element3s_indexbuffer = gl_state.draw_dynamicindexbuffer; - element3s_bufferoffset = 0; - } + if (!element3s_indexbuffer) + element3s_indexbuffer = R_BufferData_Store(numelements * sizeof(*element3s), (void *)element3s, R_BUFFERDATA_INDEX16, &element3s_bufferoffset); } else if (element3i) { - if (!element3i_indexbuffer && gl_state.usevbo_dynamicindex) - { - if (gl_state.draw_dynamicindexbuffer) - R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3i, numelements * sizeof(*element3i)); - else - gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3i, numelements * sizeof(*element3i), "temporary", true, true); - element3i_indexbuffer = gl_state.draw_dynamicindexbuffer; - element3i_bufferoffset = 0; - } + if (!element3i_indexbuffer) + element3i_indexbuffer = R_BufferData_Store(numelements * sizeof(*element3i), (void *)element3i, R_BUFFERDATA_INDEX32, &element3i_bufferoffset); } bufferobject3i = element3i_indexbuffer ? element3i_indexbuffer->bufferobject : 0; bufferoffset3i = element3i_bufferoffset; bufferobject3s = element3s_indexbuffer ? element3s_indexbuffer->bufferobject : 0; bufferoffset3s = element3s_bufferoffset; - CHECKGLERROR - r_refdef.stats.meshes++; - r_refdef.stats.meshes_elements += numelements; + r_refdef.stats[r_stat_draws]++; + r_refdef.stats[r_stat_draws_vertices] += numvertices; + r_refdef.stats[r_stat_draws_elements] += numelements; if (gl_paranoid.integer) { unsigned int i; - // LordHavoc: disabled this - it needs to be updated to handle components and gltype and stride in each array -#if 0 - unsigned int j, size; - const int *p; - // note: there's no validation done here on buffer objects because it - // is somewhat difficult to get at the data, and gl_paranoid can be - // used without buffer objects if the need arises - // (the data could be gotten using glMapBuffer but it would be very - // slow due to uncachable video memory reads) - if (!qglIsEnabled(GL_VERTEX_ARRAY)) - Con_Print("R_Mesh_Draw: vertex array not enabled\n"); - CHECKGLERROR - if (gl_state.pointer_vertex_pointer) - for (j = 0, size = numvertices * 3, p = (int *)((float *)gl_state.pointer_vertex + firstvertex * 3);j < size;j++, p++) - paranoidblah += *p; - if (gl_state.pointer_color_enabled) - { - if (!qglIsEnabled(GL_COLOR_ARRAY)) - Con_Print("R_Mesh_Draw: color array set but not enabled\n"); - CHECKGLERROR - if (gl_state.pointer_color && gl_state.pointer_color_enabled) - for (j = 0, size = numvertices * 4, p = (int *)((float *)gl_state.pointer_color + firstvertex * 4);j < size;j++, p++) - paranoidblah += *p; - } - for (i = 0;i < vid.texarrayunits;i++) - { - if (gl_state.units[i].arrayenabled) - { - GL_ClientActiveTexture(i); - if (!qglIsEnabled(GL_TEXTURE_COORD_ARRAY)) - Con_Print("R_Mesh_Draw: texcoord array set but not enabled\n"); - CHECKGLERROR - if (gl_state.units[i].pointer_texcoord && gl_state.units[i].arrayenabled) - for (j = 0, size = numvertices * gl_state.units[i].arraycomponents, p = (int *)((float *)gl_state.units[i].pointer_texcoord + firstvertex * gl_state.units[i].arraycomponents);j < size;j++, p++) - paranoidblah += *p; - } - } -#endif if (element3i) { for (i = 0;i < (unsigned int) numtriangles * 3;i++) @@ -1298,195 +1772,29 @@ void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtri } } } - CHECKGLERROR } if (r_render.integer || r_refdef.draw2dstage) { - CHECKGLERROR - if (gl_mesh_testmanualfeeding.integer) + switch(vid.renderpath) { - unsigned int i, j, element; - const GLfloat *p; - qglBegin(GL_TRIANGLES); - for (i = 0;i < (unsigned int) numtriangles * 3;i++) - { - if (element3i) - element = element3i[i]; - else if (element3s) - element = element3s[i]; - else - element = firstvertex + i; - for (j = 0;j < vid.texarrayunits;j++) - { - if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled) - { - if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT) - { - p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride); - if (vid.texarrayunits > 1) - { - if (gl_state.units[j].pointer_texcoord_components == 4) - qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2], p[3]); - else if (gl_state.units[j].pointer_texcoord_components == 3) - qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2]); - else if (gl_state.units[j].pointer_texcoord_components == 2) - qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, p[0], p[1]); - else - qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, p[0]); - } - else - { - if (gl_state.units[j].pointer_texcoord_components == 4) - qglTexCoord4f(p[0], p[1], p[2], p[3]); - else if (gl_state.units[j].pointer_texcoord_components == 3) - qglTexCoord3f(p[0], p[1], p[2]); - else if (gl_state.units[j].pointer_texcoord_components == 2) - qglTexCoord2f(p[0], p[1]); - else - qglTexCoord1f(p[0]); - } - } - else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT) - { - const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride); - if (vid.texarrayunits > 1) - { - if (gl_state.units[j].pointer_texcoord_components == 4) - qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2], s[3]); - else if (gl_state.units[j].pointer_texcoord_components == 3) - qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2]); - else if (gl_state.units[j].pointer_texcoord_components == 2) - qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, s[0], s[1]); - else if (gl_state.units[j].pointer_texcoord_components == 1) - qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, s[0]); - } - else - { - if (gl_state.units[j].pointer_texcoord_components == 4) - qglTexCoord4f(s[0], s[1], s[2], s[3]); - else if (gl_state.units[j].pointer_texcoord_components == 3) - qglTexCoord3f(s[0], s[1], s[2]); - else if (gl_state.units[j].pointer_texcoord_components == 2) - qglTexCoord2f(s[0], s[1]); - else if (gl_state.units[j].pointer_texcoord_components == 1) - qglTexCoord1f(s[0]); - } - } - else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE) - { - const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride); - if (vid.texarrayunits > 1) - { - if (gl_state.units[j].pointer_texcoord_components == 4) - qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2], sb[3]); - else if (gl_state.units[j].pointer_texcoord_components == 3) - qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2]); - else if (gl_state.units[j].pointer_texcoord_components == 2) - qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, sb[0], sb[1]); - else if (gl_state.units[j].pointer_texcoord_components == 1) - qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, sb[0]); - } - else - { - if (gl_state.units[j].pointer_texcoord_components == 4) - qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]); - else if (gl_state.units[j].pointer_texcoord_components == 3) - qglTexCoord3f(sb[0], sb[1], sb[2]); - else if (gl_state.units[j].pointer_texcoord_components == 2) - qglTexCoord2f(sb[0], sb[1]); - else if (gl_state.units[j].pointer_texcoord_components == 1) - qglTexCoord1f(sb[0]); - } - } - } - } - if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4) - { - if (gl_state.pointer_color_gltype == GL_FLOAT) - { - p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride); - qglColor4f(p[0], p[1], p[2], p[3]); - } - else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE) - { - const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride); - qglColor4ub(ub[0], ub[1], ub[2], ub[3]); - } - } - if (gl_state.pointer_vertex_gltype == GL_FLOAT) - { - p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride); - if (gl_state.pointer_vertex_components == 4) - qglVertex4f(p[0], p[1], p[2], p[3]); - else if (gl_state.pointer_vertex_components == 3) - qglVertex3f(p[0], p[1], p[2]); - else - qglVertex2f(p[0], p[1]); - } - } - qglEnd(); + case RENDERPATH_GL32: + case RENDERPATH_GLES2: CHECKGLERROR - } - else if (bufferobject3s) - { - GL_BindEBO(bufferobject3s); - if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL) - { - qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s); - CHECKGLERROR - } - else - { - qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)(firsttriangle * sizeof(unsigned short[3]))); - CHECKGLERROR - } - } - else if (bufferobject3i) - { - GL_BindEBO(bufferobject3i); - if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL) - { - qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i); - CHECKGLERROR - } - else - { - qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)(firsttriangle * sizeof(unsigned int[3]))); - CHECKGLERROR - } - } - else if (element3s) - { - GL_BindEBO(0); - if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL) - { - qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, element3s); - CHECKGLERROR - } - else + if (bufferobject3s) { - qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s); - CHECKGLERROR + GL_BindEBO(bufferobject3s); + qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);CHECKGLERROR } - } - else if (element3i) - { - GL_BindEBO(0); - if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL) + else if (bufferobject3i) { - qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, element3i); - CHECKGLERROR + GL_BindEBO(bufferobject3i); + qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);CHECKGLERROR } else { - qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i); - CHECKGLERROR + qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);CHECKGLERROR } - } - else - { - qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices); - CHECKGLERROR + break; } } } @@ -1494,75 +1802,72 @@ void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtri // restores backend state, used when done with 3D rendering void R_Mesh_Finish(void) { + R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL); } -r_meshbuffer_t *R_Mesh_CreateMeshBuffer(const void *data, size_t size, const char *name, qboolean isindexbuffer, qboolean isdynamic) +r_meshbuffer_t *R_Mesh_CreateMeshBuffer(const void *data, size_t size, const char *name, qboolean isindexbuffer, qboolean isuniformbuffer, qboolean isdynamic, qboolean isindex16) { - int bufferobject = 0; - void *devicebuffer = NULL; r_meshbuffer_t *buffer; - if (!(isdynamic ? (isindexbuffer ? gl_state.usevbo_dynamicindex : gl_state.usevbo_dynamicvertex) : (isindexbuffer ? gl_state.usevbo_staticindex : gl_state.usevbo_staticvertex))) - return NULL; - if (isindexbuffer) - { - r_refdef.stats.indexbufferuploadcount++; - r_refdef.stats.indexbufferuploadsize += size; - } - else - { - r_refdef.stats.vertexbufferuploadcount++; - r_refdef.stats.vertexbufferuploadsize += size; - } - switch(vid.renderpath) - { - case RENDERPATH_GL11: - case RENDERPATH_GL13: - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - qglGenBuffersARB(1, (GLuint *)&bufferobject); - if (isindexbuffer) - GL_BindEBO(bufferobject); - else - GL_BindVBO(bufferobject); - qglBufferDataARB(isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER_ARB : GL_ARRAY_BUFFER_ARB, size, data, isdynamic ? GL_STREAM_DRAW_ARB : GL_STATIC_DRAW_ARB); - break; - } buffer = (r_meshbuffer_t *)Mem_ExpandableArray_AllocRecord(&gl_state.meshbufferarray); memset(buffer, 0, sizeof(*buffer)); - buffer->bufferobject = bufferobject; - buffer->devicebuffer = devicebuffer; + buffer->bufferobject = 0; + buffer->devicebuffer = NULL; buffer->size = size; buffer->isindexbuffer = isindexbuffer; + buffer->isuniformbuffer = isuniformbuffer; buffer->isdynamic = isdynamic; + buffer->isindex16 = isindex16; strlcpy(buffer->name, name, sizeof(buffer->name)); + R_Mesh_UpdateMeshBuffer(buffer, data, size, false, 0); return buffer; } -void R_Mesh_UpdateMeshBuffer(r_meshbuffer_t *buffer, const void *data, size_t size) +void R_Mesh_UpdateMeshBuffer(r_meshbuffer_t *buffer, const void *data, size_t size, qboolean subdata, size_t offset) { - if (!buffer || (!buffer->bufferobject && !buffer->devicebuffer)) + if (!buffer) return; if (buffer->isindexbuffer) { - r_refdef.stats.indexbufferuploadcount++; - r_refdef.stats.indexbufferuploadsize += size; + r_refdef.stats[r_stat_indexbufferuploadcount]++; + r_refdef.stats[r_stat_indexbufferuploadsize] += (int)size; } else { - r_refdef.stats.vertexbufferuploadcount++; - r_refdef.stats.vertexbufferuploadsize += size; + r_refdef.stats[r_stat_vertexbufferuploadcount]++; + r_refdef.stats[r_stat_vertexbufferuploadsize] += (int)size; } + if (!subdata) + buffer->size = size; switch(vid.renderpath) { - case RENDERPATH_GL11: - case RENDERPATH_GL13: - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - if (buffer->isindexbuffer) + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + if (!buffer->bufferobject) + qglGenBuffers(1, (GLuint *)&buffer->bufferobject); + CHECKGLERROR + if (buffer->isuniformbuffer) + GL_BindUBO(buffer->bufferobject); + else if (buffer->isindexbuffer) GL_BindEBO(buffer->bufferobject); else GL_BindVBO(buffer->bufferobject); - qglBufferDataARB(buffer->isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER_ARB : GL_ARRAY_BUFFER_ARB, size, data, buffer->isdynamic ? GL_STREAM_DRAW_ARB : GL_STATIC_DRAW_ARB); + + { + int buffertype; + buffertype = buffer->isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER; +#ifdef GL_UNIFORM_BUFFER + if (buffer->isuniformbuffer) + buffertype = GL_UNIFORM_BUFFER; +#endif + CHECKGLERROR + if (subdata) + qglBufferSubData(buffertype, offset, size, data); + else + qglBufferData(buffertype, size, data, buffer->isdynamic ? GL_STREAM_DRAW : GL_STATIC_DRAW); + CHECKGLERROR + } + if (buffer->isuniformbuffer) + GL_BindUBO(0); break; } } @@ -1573,50 +1878,94 @@ void R_Mesh_DestroyMeshBuffer(r_meshbuffer_t *buffer) return; switch(vid.renderpath) { - case RENDERPATH_GL11: - case RENDERPATH_GL13: - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - qglDeleteBuffersARB(1, (GLuint *)&buffer->bufferobject); + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + // GL clears the binding if we delete something bound + if (gl_state.uniformbufferobject == buffer->bufferobject) + gl_state.uniformbufferobject = 0; + if (gl_state.vertexbufferobject == buffer->bufferobject) + gl_state.vertexbufferobject = 0; + if (gl_state.elementbufferobject == buffer->bufferobject) + gl_state.elementbufferobject = 0; + CHECKGLERROR + qglDeleteBuffers(1, (GLuint *)&buffer->bufferobject);CHECKGLERROR break; } Mem_ExpandableArray_FreeRecord(&gl_state.meshbufferarray, (void *)buffer); } +static const char *buffertypename[R_BUFFERDATA_COUNT] = {"vertex", "index16", "index32", "uniform"}; void GL_Mesh_ListVBOs(qboolean printeach) { int i, endindex; - size_t ebocount = 0, ebomemory = 0; - size_t vbocount = 0, vbomemory = 0; + int type; + int isdynamic; + int index16count, index16mem; + int index32count, index32mem; + int vertexcount, vertexmem; + int uniformcount, uniformmem; + int totalcount, totalmem; + size_t bufferstat[R_BUFFERDATA_COUNT][2][2]; r_meshbuffer_t *buffer; - endindex = Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray); + memset(bufferstat, 0, sizeof(bufferstat)); + endindex = (int)Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray); for (i = 0;i < endindex;i++) { buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i); if (!buffer) continue; - if (buffer->isindexbuffer) {ebocount++;ebomemory += buffer->size;if (printeach) Con_Printf("indexbuffer #%i %s = %i bytes%s\n", i, buffer->name, (int)buffer->size, buffer->isdynamic ? " (dynamic)" : " (static)");} - else {vbocount++;vbomemory += buffer->size;if (printeach) Con_Printf("vertexbuffer #%i %s = %i bytes%s\n", i, buffer->name, (int)buffer->size, buffer->isdynamic ? " (dynamic)" : " (static)");} + if (buffer->isuniformbuffer) + type = R_BUFFERDATA_UNIFORM; + else if (buffer->isindexbuffer && buffer->isindex16) + type = R_BUFFERDATA_INDEX16; + else if (buffer->isindexbuffer) + type = R_BUFFERDATA_INDEX32; + else + type = R_BUFFERDATA_VERTEX; + isdynamic = buffer->isdynamic; + bufferstat[type][isdynamic][0]++; + bufferstat[type][isdynamic][1] += buffer->size; + if (printeach) + Con_Printf("buffer #%i %s = %i bytes (%s %s)\n", i, buffer->name, (int)buffer->size, isdynamic ? "dynamic" : "static", buffertypename[type]); } - Con_Printf("vertex buffers: %i indexbuffers totalling %i bytes (%.3f MB), %i vertexbuffers totalling %i bytes (%.3f MB), combined %i bytes (%.3fMB)\n", (int)ebocount, (int)ebomemory, ebomemory / 1048576.0, (int)vbocount, (int)vbomemory, vbomemory / 1048576.0, (int)(ebomemory + vbomemory), (ebomemory + vbomemory) / 1048576.0); + index16count = (int)(bufferstat[R_BUFFERDATA_INDEX16][0][0] + bufferstat[R_BUFFERDATA_INDEX16][1][0]); + index16mem = (int)(bufferstat[R_BUFFERDATA_INDEX16][0][1] + bufferstat[R_BUFFERDATA_INDEX16][1][1]); + index32count = (int)(bufferstat[R_BUFFERDATA_INDEX32][0][0] + bufferstat[R_BUFFERDATA_INDEX32][1][0]); + index32mem = (int)(bufferstat[R_BUFFERDATA_INDEX32][0][1] + bufferstat[R_BUFFERDATA_INDEX32][1][1]); + vertexcount = (int)(bufferstat[R_BUFFERDATA_VERTEX ][0][0] + bufferstat[R_BUFFERDATA_VERTEX ][1][0]); + vertexmem = (int)(bufferstat[R_BUFFERDATA_VERTEX ][0][1] + bufferstat[R_BUFFERDATA_VERTEX ][1][1]); + uniformcount = (int)(bufferstat[R_BUFFERDATA_UNIFORM][0][0] + bufferstat[R_BUFFERDATA_UNIFORM][1][0]); + uniformmem = (int)(bufferstat[R_BUFFERDATA_UNIFORM][0][1] + bufferstat[R_BUFFERDATA_UNIFORM][1][1]); + totalcount = index16count + index32count + vertexcount + uniformcount; + totalmem = index16mem + index32mem + vertexmem + uniformmem; + Con_Printf("%i 16bit indexbuffers totalling %i bytes (%.3f MB)\n%i 32bit indexbuffers totalling %i bytes (%.3f MB)\n%i vertexbuffers totalling %i bytes (%.3f MB)\n%i uniformbuffers totalling %i bytes (%.3f MB)\ncombined %i buffers totalling %i bytes (%.3fMB)\n", index16count, index16mem, index16mem / 10248576.0, index32count, index32mem, index32mem / 10248576.0, vertexcount, vertexmem, vertexmem / 10248576.0, uniformcount, uniformmem, uniformmem / 10248576.0, totalcount, totalmem, totalmem / 10248576.0); } void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset) { - int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0; - if (gl_state.pointer_vertex_components != components || gl_state.pointer_vertex_gltype != gltype || gl_state.pointer_vertex_stride != stride || gl_state.pointer_vertex_pointer != pointer || gl_state.pointer_vertex_vertexbuffer != vertexbuffer || gl_state.pointer_vertex_offset != bufferoffset) + switch(vid.renderpath) { - gl_state.pointer_vertex_components = components; - gl_state.pointer_vertex_gltype = gltype; - gl_state.pointer_vertex_stride = stride; - gl_state.pointer_vertex_pointer = pointer; - gl_state.pointer_vertex_vertexbuffer = vertexbuffer; - gl_state.pointer_vertex_offset = bufferoffset; - CHECKGLERROR - GL_BindVBO(bufferobject); - qglVertexPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + if (gl_state.pointer_vertex_components != components || gl_state.pointer_vertex_gltype != gltype || gl_state.pointer_vertex_stride != stride || gl_state.pointer_vertex_pointer != pointer || gl_state.pointer_vertex_vertexbuffer != vertexbuffer || gl_state.pointer_vertex_offset != bufferoffset) + { + int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0; + if (!bufferobject && gl_paranoid.integer) + Con_DPrintf("Warning: no bufferobject in R_Mesh_VertexPointer(%i, %i, %i, %p, %p, %08x)", components, gltype, (int)stride, pointer, vertexbuffer, (unsigned int)bufferoffset); + gl_state.pointer_vertex_components = components; + gl_state.pointer_vertex_gltype = gltype; + gl_state.pointer_vertex_stride = stride; + gl_state.pointer_vertex_pointer = pointer; + gl_state.pointer_vertex_vertexbuffer = vertexbuffer; + gl_state.pointer_vertex_offset = bufferoffset; + CHECKGLERROR + GL_BindVBO(bufferobject); + // LordHavoc: special flag added to gltype for unnormalized types + qglVertexAttribPointer(GLSLATTRIB_POSITION, components, gltype & ~0x80000000, (gltype & 0x80000000) == 0, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR + } + break; } } @@ -1624,40 +1973,48 @@ void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void * { // note: vertexbuffer may be non-NULL even if pointer is NULL, so check // the pointer only. - if (pointer) + switch(vid.renderpath) { - int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0; - // caller wants color array enabled - if (!gl_state.pointer_color_enabled) - { - gl_state.pointer_color_enabled = true; - CHECKGLERROR - qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR - } - if (gl_state.pointer_color_components != components || gl_state.pointer_color_gltype != gltype || gl_state.pointer_color_stride != stride || gl_state.pointer_color_pointer != pointer || gl_state.pointer_color_vertexbuffer != vertexbuffer || gl_state.pointer_color_offset != bufferoffset) + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if (pointer) { - gl_state.pointer_color_components = components; - gl_state.pointer_color_gltype = gltype; - gl_state.pointer_color_stride = stride; - gl_state.pointer_color_pointer = pointer; - gl_state.pointer_color_vertexbuffer = vertexbuffer; - gl_state.pointer_color_offset = bufferoffset; - CHECKGLERROR - GL_BindVBO(bufferobject); - qglColorPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR + // caller wants color array enabled + int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0; + if (!gl_state.pointer_color_enabled) + { + gl_state.pointer_color_enabled = true; + CHECKGLERROR + qglEnableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR + } + if (gl_state.pointer_color_components != components || gl_state.pointer_color_gltype != gltype || gl_state.pointer_color_stride != stride || gl_state.pointer_color_pointer != pointer || gl_state.pointer_color_vertexbuffer != vertexbuffer || gl_state.pointer_color_offset != bufferoffset) + { + gl_state.pointer_color_components = components; + gl_state.pointer_color_gltype = gltype; + gl_state.pointer_color_stride = stride; + gl_state.pointer_color_pointer = pointer; + gl_state.pointer_color_vertexbuffer = vertexbuffer; + gl_state.pointer_color_offset = bufferoffset; + CHECKGLERROR + GL_BindVBO(bufferobject); + // LordHavoc: special flag added to gltype for unnormalized types + qglVertexAttribPointer(GLSLATTRIB_COLOR, components, gltype & ~0x80000000, (gltype & 0x80000000) == 0, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR + } } - } - else - { - // caller wants color array disabled - if (gl_state.pointer_color_enabled) + else { - gl_state.pointer_color_enabled = false; - CHECKGLERROR - qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR - // when color array is on the glColor gets trashed, set it again - qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR + // caller wants color array disabled + if (gl_state.pointer_color_enabled) + { + gl_state.pointer_color_enabled = false; + CHECKGLERROR + qglDisableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR + // when color array is on the current color gets trashed, set it again + qglVertexAttrib4f(GLSLATTRIB_COLOR, gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR + } } + break; } } @@ -1665,42 +2022,46 @@ void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, si { gltextureunit_t *unit = gl_state.units + unitnum; // update array settings - CHECKGLERROR // note: there is no need to check bufferobject here because all cases // that involve a valid bufferobject also supply a texcoord array - if (pointer) + switch(vid.renderpath) { - int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0; - // texture array unit is enabled, enable the array - if (!unit->arrayenabled) - { - unit->arrayenabled = true; - GL_ClientActiveTexture(unitnum); - qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR - } - // texcoord array - if (unit->pointer_texcoord_components != components || unit->pointer_texcoord_gltype != gltype || unit->pointer_texcoord_stride != stride || unit->pointer_texcoord_pointer != pointer || unit->pointer_texcoord_vertexbuffer != vertexbuffer || unit->pointer_texcoord_offset != bufferoffset) + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + CHECKGLERROR + if (pointer) { - unit->pointer_texcoord_components = components; - unit->pointer_texcoord_gltype = gltype; - unit->pointer_texcoord_stride = stride; - unit->pointer_texcoord_pointer = pointer; - unit->pointer_texcoord_vertexbuffer = vertexbuffer; - unit->pointer_texcoord_offset = bufferoffset; - GL_ClientActiveTexture(unitnum); - GL_BindVBO(bufferobject); - qglTexCoordPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR + int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0; + // texture array unit is enabled, enable the array + if (!unit->arrayenabled) + { + unit->arrayenabled = true; + qglEnableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR + } + // texcoord array + if (unit->pointer_texcoord_components != components || unit->pointer_texcoord_gltype != gltype || unit->pointer_texcoord_stride != stride || unit->pointer_texcoord_pointer != pointer || unit->pointer_texcoord_vertexbuffer != vertexbuffer || unit->pointer_texcoord_offset != bufferoffset) + { + unit->pointer_texcoord_components = components; + unit->pointer_texcoord_gltype = gltype; + unit->pointer_texcoord_stride = stride; + unit->pointer_texcoord_pointer = pointer; + unit->pointer_texcoord_vertexbuffer = vertexbuffer; + unit->pointer_texcoord_offset = bufferoffset; + GL_BindVBO(bufferobject); + // LordHavoc: special flag added to gltype for unnormalized types + qglVertexAttribPointer(unitnum+GLSLATTRIB_TEXCOORD0, components, gltype & ~0x80000000, (gltype & 0x80000000) == 0, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR + } } - } - else - { - // texture array unit is disabled, disable the array - if (unit->arrayenabled) + else { - unit->arrayenabled = false; - GL_ClientActiveTexture(unitnum); - qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR + // texture array unit is disabled, disable the array + if (unit->arrayenabled) + { + unit->arrayenabled = false; + qglDisableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR + } } + break; } } @@ -1713,239 +2074,67 @@ int R_Mesh_TexBound(unsigned int unitnum, int id) return unit->t2d; if (id == GL_TEXTURE_3D) return unit->t3d; - if (id == GL_TEXTURE_CUBE_MAP_ARB) + if (id == GL_TEXTURE_CUBE_MAP) return unit->tcubemap; - if (id == GL_TEXTURE_RECTANGLE_ARB) - return unit->trectangle; return 0; } void R_Mesh_CopyToTexture(rtexture_t *tex, int tx, int ty, int sx, int sy, int width, int height) { - R_Mesh_TexBind(0, tex); - GL_ActiveTexture(0);CHECKGLERROR - qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, sx, sy, width, height);CHECKGLERROR -} - -void R_Mesh_TexBind(unsigned int unitnum, rtexture_t *tex) -{ - gltextureunit_t *unit = gl_state.units + unitnum; - int tex2d, tex3d, texcubemap, texnum; - if (unitnum >= vid.teximageunits) - return; switch(vid.renderpath) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - if (!tex) - tex = r_texture_white; - texnum = R_GetTexture(tex); - switch(tex->gltexturetypeenum) - { - case GL_TEXTURE_2D: if (unit->t2d != texnum) {GL_ActiveTexture(unitnum);unit->t2d = texnum;qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR}break; - case GL_TEXTURE_3D: if (unit->t3d != texnum) {GL_ActiveTexture(unitnum);unit->t3d = texnum;qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR}break; - case GL_TEXTURE_CUBE_MAP_ARB: if (unit->tcubemap != texnum) {GL_ActiveTexture(unitnum);unit->tcubemap = texnum;qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR}break; - case GL_TEXTURE_RECTANGLE_ARB: if (unit->trectangle != texnum) {GL_ActiveTexture(unitnum);unit->trectangle = texnum;qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, unit->trectangle);CHECKGLERROR}break; - } - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - tex2d = 0; - tex3d = 0; - texcubemap = 0; - if (tex) - { - texnum = R_GetTexture(tex); - switch(tex->gltexturetypeenum) - { - case GL_TEXTURE_2D: - tex2d = texnum; - break; - case GL_TEXTURE_3D: - tex3d = texnum; - break; - case GL_TEXTURE_CUBE_MAP_ARB: - texcubemap = texnum; - break; - } - } - // update 2d texture binding - if (unit->t2d != tex2d) - { - GL_ActiveTexture(unitnum); - if (tex2d) - { - if (unit->t2d == 0) - { - qglEnable(GL_TEXTURE_2D);CHECKGLERROR - } - } - else - { - if (unit->t2d) - { - qglDisable(GL_TEXTURE_2D);CHECKGLERROR - } - } - unit->t2d = tex2d; - qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR - } - // update 3d texture binding - if (unit->t3d != tex3d) - { - GL_ActiveTexture(unitnum); - if (tex3d) - { - if (unit->t3d == 0) - { - qglEnable(GL_TEXTURE_3D);CHECKGLERROR - } - } - else - { - if (unit->t3d) - { - qglDisable(GL_TEXTURE_3D);CHECKGLERROR - } - } - unit->t3d = tex3d; - qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR - } - // update cubemap texture binding - if (unit->tcubemap != texcubemap) - { - GL_ActiveTexture(unitnum); - if (texcubemap) - { - if (unit->tcubemap == 0) - { - qglEnable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR - } - } - else - { - if (unit->tcubemap) - { - qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR - } - } - unit->tcubemap = texcubemap; - qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR - } + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + R_Mesh_TexBind(0, tex); + GL_ActiveTexture(0);CHECKGLERROR + qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, sx, sy, width, height);CHECKGLERROR break; } } -void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix) +void R_Mesh_ClearBindingsForTexture(int texnum) { - gltextureunit_t *unit = gl_state.units + unitnum; - if (matrix && matrix->m[3][3]) - { - // texmatrix specified, check if it is different - if (!unit->texmatrixenabled || memcmp(&unit->matrix, matrix, sizeof(matrix4x4_t))) - { - float glmatrix[16]; - unit->texmatrixenabled = true; - unit->matrix = *matrix; - CHECKGLERROR - Matrix4x4_ToArrayFloatGL(&unit->matrix, glmatrix); - GL_ActiveTexture(unitnum); - qglMatrixMode(GL_TEXTURE);CHECKGLERROR - qglLoadMatrixf(glmatrix);CHECKGLERROR - qglMatrixMode(GL_MODELVIEW);CHECKGLERROR - } - } - else + gltextureunit_t *unit; + unsigned int unitnum; + // this doesn't really unbind the texture, but it does prevent a mistaken "do nothing" behavior on the next time this same texnum is bound on the same unit as the same type (this mainly affects r_shadow_bouncegrid because 3D textures are so rarely used) + for (unitnum = 0;unitnum < vid.teximageunits;unitnum++) { - // no texmatrix specified, revert to identity - if (unit->texmatrixenabled) - { - unit->texmatrixenabled = false; - unit->matrix = identitymatrix; - CHECKGLERROR - GL_ActiveTexture(unitnum); - qglMatrixMode(GL_TEXTURE);CHECKGLERROR - qglLoadIdentity();CHECKGLERROR - qglMatrixMode(GL_MODELVIEW);CHECKGLERROR - } + unit = gl_state.units + unitnum; + if (unit->t2d == texnum) + unit->t2d = -1; + if (unit->t3d == texnum) + unit->t3d = -1; + if (unit->tcubemap == texnum) + unit->tcubemap = -1; } } -void R_Mesh_TexCombine(unsigned int unitnum, int combinergb, int combinealpha, int rgbscale, int alphascale) +void R_Mesh_TexBind(unsigned int unitnum, rtexture_t *tex) { gltextureunit_t *unit = gl_state.units + unitnum; - CHECKGLERROR + int texnum; + if (unitnum >= vid.teximageunits) + return; + if (unit->texture == tex) + return; switch(vid.renderpath) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - // do nothing - break; - case RENDERPATH_GL13: - // GL_ARB_texture_env_combine - if (!combinergb) - combinergb = GL_MODULATE; - if (!combinealpha) - combinealpha = GL_MODULATE; - if (!rgbscale) - rgbscale = 1; - if (!alphascale) - alphascale = 1; - if (combinergb != combinealpha || rgbscale != 1 || alphascale != 1) - { - if (combinergb == GL_DECAL) - combinergb = GL_INTERPOLATE_ARB; - if (unit->combine != GL_COMBINE_ARB) - { - unit->combine = GL_COMBINE_ARB; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);CHECKGLERROR - qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);CHECKGLERROR // for GL_INTERPOLATE_ARB mode - } - if (unit->combinergb != combinergb) - { - unit->combinergb = combinergb; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, unit->combinergb);CHECKGLERROR - } - if (unit->combinealpha != combinealpha) - { - unit->combinealpha = combinealpha; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, unit->combinealpha);CHECKGLERROR - } - if (unit->rgbscale != rgbscale) - { - unit->rgbscale = rgbscale; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, unit->rgbscale);CHECKGLERROR - } - if (unit->alphascale != alphascale) - { - unit->alphascale = alphascale; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, unit->alphascale);CHECKGLERROR - } - } - else + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + if (!tex) { - if (unit->combine != combinergb) - { - unit->combine = combinergb; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR - } + tex = r_texture_white; + // not initialized enough yet... + if (!tex) + return; } - break; - case RENDERPATH_GL11: - // normal GL texenv - if (!combinergb) - combinergb = GL_MODULATE; - if (unit->combine != combinergb) + unit->texture = tex; + texnum = R_GetTexture(tex); + switch(tex->gltexturetypeenum) { - unit->combine = combinergb; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR + case GL_TEXTURE_2D: if (unit->t2d != texnum) {GL_ActiveTexture(unitnum);unit->t2d = texnum;qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR}break; + case GL_TEXTURE_3D: if (unit->t3d != texnum) {GL_ActiveTexture(unitnum);unit->t3d = texnum;qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR}break; + case GL_TEXTURE_CUBE_MAP: if (unit->tcubemap != texnum) {GL_ActiveTexture(unitnum);unit->tcubemap = texnum;qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR}break; } break; } @@ -1957,524 +2146,124 @@ void R_Mesh_ResetTextureState(void) BACKENDACTIVECHECK - CHECKGLERROR - switch(vid.renderpath) - { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - for (unitnum = 0;unitnum < vid.teximageunits;unitnum++) - { - gltextureunit_t *unit = gl_state.units + unitnum; - if (unit->t2d) - { - unit->t2d = 0; - GL_ActiveTexture(unitnum); - qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR - } - if (unit->t3d) - { - unit->t3d = 0; - GL_ActiveTexture(unitnum); - qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR - } - if (unit->tcubemap) - { - unit->tcubemap = 0; - GL_ActiveTexture(unitnum); - qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR - } - if (unit->trectangle) - { - unit->trectangle = 0; - GL_ActiveTexture(unitnum); - qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, unit->trectangle);CHECKGLERROR - } - } - for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++) - { - gltextureunit_t *unit = gl_state.units + unitnum; - if (unit->arrayenabled) - { - unit->arrayenabled = false; - GL_ClientActiveTexture(unitnum); - qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR - } - } - for (unitnum = 0;unitnum < vid.texunits;unitnum++) - { - gltextureunit_t *unit = gl_state.units + unitnum; - if (unit->texmatrixenabled) - { - unit->texmatrixenabled = false; - unit->matrix = identitymatrix; - CHECKGLERROR - GL_ActiveTexture(unitnum); - qglMatrixMode(GL_TEXTURE);CHECKGLERROR - qglLoadIdentity();CHECKGLERROR - qglMatrixMode(GL_MODELVIEW);CHECKGLERROR - } - } - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - for (unitnum = 0;unitnum < vid.texunits;unitnum++) - { - gltextureunit_t *unit = gl_state.units + unitnum; - if (unit->t2d) - { - unit->t2d = 0; - GL_ActiveTexture(unitnum); - qglDisable(GL_TEXTURE_2D);CHECKGLERROR - qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR - } - if (unit->t3d) - { - unit->t3d = 0; - GL_ActiveTexture(unitnum); - qglDisable(GL_TEXTURE_3D);CHECKGLERROR - qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR - } - if (unit->tcubemap) - { - unit->tcubemap = 0; - GL_ActiveTexture(unitnum); - qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR - qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR - } - if (unit->trectangle) - { - unit->trectangle = 0; - GL_ActiveTexture(unitnum); - qglDisable(GL_TEXTURE_RECTANGLE_ARB);CHECKGLERROR - qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, unit->trectangle);CHECKGLERROR - } - if (unit->arrayenabled) - { - unit->arrayenabled = false; - GL_ClientActiveTexture(unitnum); - qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR - } - if (unit->texmatrixenabled) - { - unit->texmatrixenabled = false; - unit->matrix = identitymatrix; - CHECKGLERROR - GL_ActiveTexture(unitnum); - qglMatrixMode(GL_TEXTURE);CHECKGLERROR - qglLoadIdentity();CHECKGLERROR - qglMatrixMode(GL_MODELVIEW);CHECKGLERROR - } - if (unit->combine != GL_MODULATE) - { - unit->combine = GL_MODULATE; - GL_ActiveTexture(unitnum); - qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR - } - } - break; - } -} - - - -r_vertexposition_t *R_Mesh_PrepareVertices_Position_Lock(int numvertices) -{ - size_t size; - size = sizeof(r_vertexposition_t) * numvertices; - if (gl_state.preparevertices_tempdatamaxsize < size) - { - gl_state.preparevertices_tempdatamaxsize = size; - gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize); - } - gl_state.preparevertices_vertexposition = (r_vertexposition_t *)gl_state.preparevertices_tempdata; - gl_state.preparevertices_numvertices = numvertices; - return gl_state.preparevertices_vertexposition; + for (unitnum = 0;unitnum < vid.teximageunits;unitnum++) + R_Mesh_TexBind(unitnum, NULL); + for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++) + R_Mesh_TexCoordPointer(unitnum, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); } -qboolean R_Mesh_PrepareVertices_Position_Unlock(void) +void R_Mesh_PrepareVertices_Vertex3f(int numvertices, const float *vertex3f, const r_meshbuffer_t *vertexbuffer, int bufferoffset) { - R_Mesh_PrepareVertices_Position(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexposition, NULL); - gl_state.preparevertices_vertexposition = NULL; - gl_state.preparevertices_numvertices = 0; - return true; -} - -void R_Mesh_PrepareVertices_Position_Arrays(int numvertices, const float *vertex3f) -{ - int i; - r_vertexposition_t *vertex; - switch(vid.renderpath) + // upload temporary vertexbuffer for this rendering + if (!vertexbuffer) + vertexbuffer = R_BufferData_Store(numvertices * sizeof(float[3]), (void *)vertex3f, R_BUFFERDATA_VERTEX, &bufferoffset); + if (vertexbuffer) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0); + R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, bufferoffset); R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0); R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - if (vid.texunits >= 2) - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - if (vid.texunits >= 3) - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - break; - } - - // no quick path for this case, convert to vertex structs - vertex = R_Mesh_PrepareVertices_Position_Lock(numvertices); - for (i = 0;i < numvertices;i++) - VectorCopy(vertex3f + 3*i, vertex[i].vertex3f); - R_Mesh_PrepareVertices_Position_Unlock(); - R_Mesh_PrepareVertices_Position(numvertices, vertex, NULL); -} - -void R_Mesh_PrepareVertices_Position(int numvertices, const r_vertexposition_t *vertex, const r_meshbuffer_t *vertexbuffer) -{ - // upload temporary vertexbuffer for this rendering - if (!gl_state.usevbo_staticvertex) - vertexbuffer = NULL; - if (!vertexbuffer && gl_state.usevbo_dynamicvertex) - { - if (gl_state.preparevertices_dynamicvertexbuffer) - R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex)); - else - gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true); - vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer; - } - if (vertexbuffer) - { - switch(vid.renderpath) - { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL13: - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL11: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , vertexbuffer, (int)((unsigned char *)vertex->vertex3f - (unsigned char *)vertex)); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - break; - } - return; + R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); + R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0); + R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0); } - switch(vid.renderpath) + else { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL13: - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL11: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , NULL, 0); + R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0); R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0); R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - break; - } -} - - - -r_vertexgeneric_t *R_Mesh_PrepareVertices_Generic_Lock(int numvertices) -{ - size_t size; - size = sizeof(r_vertexgeneric_t) * numvertices; - if (gl_state.preparevertices_tempdatamaxsize < size) - { - gl_state.preparevertices_tempdatamaxsize = size; - gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize); - } - gl_state.preparevertices_vertexgeneric = (r_vertexgeneric_t *)gl_state.preparevertices_tempdata; - gl_state.preparevertices_numvertices = numvertices; - return gl_state.preparevertices_vertexgeneric; -} - -qboolean R_Mesh_PrepareVertices_Generic_Unlock(void) -{ - R_Mesh_PrepareVertices_Generic(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexgeneric, NULL); - gl_state.preparevertices_vertexgeneric = NULL; - gl_state.preparevertices_numvertices = 0; - return true; -} - -void R_Mesh_PrepareVertices_Generic_Arrays(int numvertices, const float *vertex3f, const float *color4f, const float *texcoord2f) -{ - int i; - r_vertexgeneric_t *vertex; - switch(vid.renderpath) - { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - if (gl_mesh_separatearrays.integer) - { - R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0); - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - return; - } - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - if (gl_mesh_separatearrays.integer) - { - R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0); - if (vid.texunits >= 2) - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - if (vid.texunits >= 3) - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - return; - } - break; - } - - // no quick path for this case, convert to vertex structs - vertex = R_Mesh_PrepareVertices_Generic_Lock(numvertices); - for (i = 0;i < numvertices;i++) - VectorCopy(vertex3f + 3*i, vertex[i].vertex3f); - if (color4f) - { - for (i = 0;i < numvertices;i++) - Vector4Scale(color4f + 4*i, 255.0f, vertex[i].color4ub); - } - else - { - float tempcolor4f[4]; - unsigned char tempcolor4ub[4]; - Vector4Scale(gl_state.color4f, 255.0f, tempcolor4f); - tempcolor4ub[0] = (unsigned char)bound(0.0f, tempcolor4f[0], 255.0f); - tempcolor4ub[1] = (unsigned char)bound(0.0f, tempcolor4f[1], 255.0f); - tempcolor4ub[2] = (unsigned char)bound(0.0f, tempcolor4f[2], 255.0f); - tempcolor4ub[3] = (unsigned char)bound(0.0f, tempcolor4f[3], 255.0f); - for (i = 0;i < numvertices;i++) - Vector4Copy(tempcolor4ub, vertex[i].color4ub); - } - if (texcoord2f) - for (i = 0;i < numvertices;i++) - Vector2Copy(texcoord2f + 2*i, vertex[i].texcoord2f); - R_Mesh_PrepareVertices_Generic_Unlock(); - R_Mesh_PrepareVertices_Generic(numvertices, vertex, NULL); -} - -void R_Mesh_PrepareVertices_Generic(int numvertices, const r_vertexgeneric_t *vertex, const r_meshbuffer_t *vertexbuffer) -{ - // upload temporary vertexbuffer for this rendering - if (!gl_state.usevbo_staticvertex) - vertexbuffer = NULL; - if (!vertexbuffer && gl_state.usevbo_dynamicvertex) - { - if (gl_state.preparevertices_dynamicvertexbuffer) - R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex)); - else - gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true); - vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer; - } - if (vertexbuffer) - { - switch(vid.renderpath) - { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL13: - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL11: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , vertexbuffer, (int)((unsigned char *)vertex->vertex3f - (unsigned char *)vertex)); - R_Mesh_ColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub , vertexbuffer, (int)((unsigned char *)vertex->color4ub - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoord2f , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f - (unsigned char *)vertex)); - break; - } - return; - } - switch(vid.renderpath) - { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: + R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL13: - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - case RENDERPATH_GL11: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , NULL, 0); - R_Mesh_ColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub , NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoord2f , NULL, 0); - break; + R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); + R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0); + R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0); } } - - -r_vertexmesh_t *R_Mesh_PrepareVertices_Mesh_Lock(int numvertices) -{ - size_t size; - size = sizeof(r_vertexmesh_t) * numvertices; - if (gl_state.preparevertices_tempdatamaxsize < size) - { - gl_state.preparevertices_tempdatamaxsize = size; - gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize); - } - gl_state.preparevertices_vertexmesh = (r_vertexmesh_t *)gl_state.preparevertices_tempdata; - gl_state.preparevertices_numvertices = numvertices; - return gl_state.preparevertices_vertexmesh; -} - -qboolean R_Mesh_PrepareVertices_Mesh_Unlock(void) +void R_Mesh_PrepareVertices_Generic_Arrays(int numvertices, const float *vertex3f, const float *color4f, const float *texcoord2f) { - R_Mesh_PrepareVertices_Mesh(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexmesh, NULL); - gl_state.preparevertices_vertexmesh = NULL; - gl_state.preparevertices_numvertices = 0; - return true; + r_meshbuffer_t *buffer_vertex3f = NULL; + r_meshbuffer_t *buffer_color4f = NULL; + r_meshbuffer_t *buffer_texcoord2f = NULL; + int bufferoffset_vertex3f = 0; + int bufferoffset_color4f = 0; + int bufferoffset_texcoord2f = 0; + buffer_color4f = R_BufferData_Store(numvertices * sizeof(float[4]), color4f , R_BUFFERDATA_VERTEX, &bufferoffset_color4f ); + buffer_vertex3f = R_BufferData_Store(numvertices * sizeof(float[3]), vertex3f , R_BUFFERDATA_VERTEX, &bufferoffset_vertex3f ); + buffer_texcoord2f = R_BufferData_Store(numvertices * sizeof(float[2]), texcoord2f, R_BUFFERDATA_VERTEX, &bufferoffset_texcoord2f); + R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(float[3]) , vertex3f , buffer_vertex3f , bufferoffset_vertex3f ); + R_Mesh_ColorPointer( 4, GL_FLOAT , sizeof(float[4]) , color4f , buffer_color4f , bufferoffset_color4f ); + R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(float[2]) , texcoord2f , buffer_texcoord2f , bufferoffset_texcoord2f ); + R_Mesh_TexCoordPointer(1, 3, GL_FLOAT , sizeof(float[3]) , NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(2, 3, GL_FLOAT , sizeof(float[3]) , NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(3, 3, GL_FLOAT , sizeof(float[3]) , NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(4, 2, GL_FLOAT , sizeof(float[2]) , NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(5, 2, GL_FLOAT , sizeof(float[2]) , NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL , NULL , 0 ); } void R_Mesh_PrepareVertices_Mesh_Arrays(int numvertices, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const float *color4f, const float *texcoordtexture2f, const float *texcoordlightmap2f) { - int i; - r_vertexmesh_t *vertex; - switch(vid.renderpath) + r_meshbuffer_t *buffer_vertex3f = NULL; + r_meshbuffer_t *buffer_color4f = NULL; + r_meshbuffer_t *buffer_texcoordtexture2f = NULL; + r_meshbuffer_t *buffer_svector3f = NULL; + r_meshbuffer_t *buffer_tvector3f = NULL; + r_meshbuffer_t *buffer_normal3f = NULL; + r_meshbuffer_t *buffer_texcoordlightmap2f = NULL; + int bufferoffset_vertex3f = 0; + int bufferoffset_color4f = 0; + int bufferoffset_texcoordtexture2f = 0; + int bufferoffset_svector3f = 0; + int bufferoffset_tvector3f = 0; + int bufferoffset_normal3f = 0; + int bufferoffset_texcoordlightmap2f = 0; + buffer_color4f = R_BufferData_Store(numvertices * sizeof(float[4]), color4f , R_BUFFERDATA_VERTEX, &bufferoffset_color4f ); + buffer_vertex3f = R_BufferData_Store(numvertices * sizeof(float[3]), vertex3f , R_BUFFERDATA_VERTEX, &bufferoffset_vertex3f ); + buffer_svector3f = R_BufferData_Store(numvertices * sizeof(float[3]), svector3f , R_BUFFERDATA_VERTEX, &bufferoffset_svector3f ); + buffer_tvector3f = R_BufferData_Store(numvertices * sizeof(float[3]), tvector3f , R_BUFFERDATA_VERTEX, &bufferoffset_tvector3f ); + buffer_normal3f = R_BufferData_Store(numvertices * sizeof(float[3]), normal3f , R_BUFFERDATA_VERTEX, &bufferoffset_normal3f ); + buffer_texcoordtexture2f = R_BufferData_Store(numvertices * sizeof(float[2]), texcoordtexture2f , R_BUFFERDATA_VERTEX, &bufferoffset_texcoordtexture2f ); + buffer_texcoordlightmap2f = R_BufferData_Store(numvertices * sizeof(float[2]), texcoordlightmap2f, R_BUFFERDATA_VERTEX, &bufferoffset_texcoordlightmap2f); + R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(float[3]) , vertex3f , buffer_vertex3f , bufferoffset_vertex3f ); + R_Mesh_ColorPointer( 4, GL_FLOAT , sizeof(float[4]) , color4f , buffer_color4f , bufferoffset_color4f ); + R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(float[2]) , texcoordtexture2f , buffer_texcoordtexture2f , bufferoffset_texcoordtexture2f ); + R_Mesh_TexCoordPointer(1, 3, GL_FLOAT , sizeof(float[3]) , svector3f , buffer_svector3f , bufferoffset_svector3f ); + R_Mesh_TexCoordPointer(2, 3, GL_FLOAT , sizeof(float[3]) , tvector3f , buffer_tvector3f , bufferoffset_tvector3f ); + R_Mesh_TexCoordPointer(3, 3, GL_FLOAT , sizeof(float[3]) , normal3f , buffer_normal3f , bufferoffset_normal3f ); + R_Mesh_TexCoordPointer(4, 2, GL_FLOAT , sizeof(float[2]) , texcoordlightmap2f, buffer_texcoordlightmap2f, bufferoffset_texcoordlightmap2f); + R_Mesh_TexCoordPointer(5, 2, GL_FLOAT , sizeof(float[2]) , NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL , NULL , 0 ); + R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL , NULL , 0 ); +} + +void GL_BlendEquationSubtract(qboolean negated) +{ + CHECKGLERROR + if(negated) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - if (gl_mesh_separatearrays.integer) - { - R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0); - R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), svector3f, NULL, 0); - R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), tvector3f, NULL, 0); - R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), normal3f, NULL, 0); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0); - return; - } - break; - case RENDERPATH_GL13: - case RENDERPATH_GL11: - if (gl_mesh_separatearrays.integer) + switch(vid.renderpath) { - R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0); - R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0); - if (vid.texunits >= 2) - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0); - if (vid.texunits >= 3) - R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0); - return; + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT);CHECKGLERROR + break; } - break; - } - - vertex = R_Mesh_PrepareVertices_Mesh_Lock(numvertices); - for (i = 0;i < numvertices;i++) - VectorCopy(vertex3f + 3*i, vertex[i].vertex3f); - if (svector3f) - for (i = 0;i < numvertices;i++) - VectorCopy(svector3f + 3*i, vertex[i].svector3f); - if (tvector3f) - for (i = 0;i < numvertices;i++) - VectorCopy(tvector3f + 3*i, vertex[i].tvector3f); - if (normal3f) - for (i = 0;i < numvertices;i++) - VectorCopy(normal3f + 3*i, vertex[i].normal3f); - if (color4f) - { - for (i = 0;i < numvertices;i++) - Vector4Scale(color4f + 4*i, 255.0f, vertex[i].color4ub); } else - { - float tempcolor4f[4]; - unsigned char tempcolor4ub[4]; - Vector4Scale(gl_state.color4f, 255.0f, tempcolor4f); - tempcolor4ub[0] = (unsigned char)bound(0.0f, tempcolor4f[0], 255.0f); - tempcolor4ub[1] = (unsigned char)bound(0.0f, tempcolor4f[1], 255.0f); - tempcolor4ub[2] = (unsigned char)bound(0.0f, tempcolor4f[2], 255.0f); - tempcolor4ub[3] = (unsigned char)bound(0.0f, tempcolor4f[3], 255.0f); - for (i = 0;i < numvertices;i++) - Vector4Copy(tempcolor4ub, vertex[i].color4ub); - } - if (texcoordtexture2f) - for (i = 0;i < numvertices;i++) - Vector2Copy(texcoordtexture2f + 2*i, vertex[i].texcoordtexture2f); - if (texcoordlightmap2f) - for (i = 0;i < numvertices;i++) - Vector2Copy(texcoordlightmap2f + 2*i, vertex[i].texcoordlightmap2f); - R_Mesh_PrepareVertices_Mesh_Unlock(); - R_Mesh_PrepareVertices_Mesh(numvertices, vertex, NULL); -} - -void R_Mesh_PrepareVertices_Mesh(int numvertices, const r_vertexmesh_t *vertex, const r_meshbuffer_t *vertexbuffer) -{ - // upload temporary vertexbuffer for this rendering - if (!gl_state.usevbo_staticvertex) - vertexbuffer = NULL; - if (!vertexbuffer && gl_state.usevbo_dynamicvertex) - { - if (gl_state.preparevertices_dynamicvertexbuffer) - R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex)); - else - gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true); - vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer; - } - if (vertexbuffer) { switch(vid.renderpath) { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , vertexbuffer, (int)((unsigned char *)vertex->vertex3f - (unsigned char *)vertex)); - R_Mesh_ColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub , vertexbuffer, (int)((unsigned char *)vertex->color4ub - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(1, 3, GL_FLOAT , sizeof(*vertex), vertex->svector3f , vertexbuffer, (int)((unsigned char *)vertex->svector3f - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(2, 3, GL_FLOAT , sizeof(*vertex), vertex->tvector3f , vertexbuffer, (int)((unsigned char *)vertex->tvector3f - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(3, 4, GL_FLOAT , sizeof(*vertex), vertex->normal3f , vertexbuffer, (int)((unsigned char *)vertex->normal3f - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex)); - break; - case RENDERPATH_GL13: - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex)); - case RENDERPATH_GL11: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , vertexbuffer, (int)((unsigned char *)vertex->vertex3f - (unsigned char *)vertex)); - R_Mesh_ColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub , vertexbuffer, (int)((unsigned char *)vertex->color4ub - (unsigned char *)vertex)); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f - (unsigned char *)vertex)); + case RENDERPATH_GL32: + case RENDERPATH_GLES2: + qglBlendEquationEXT(GL_FUNC_ADD);CHECKGLERROR break; } - return; - } - switch(vid.renderpath) - { - case RENDERPATH_GL20: - case RENDERPATH_CGGL: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , NULL, 0); - R_Mesh_ColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub , NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0); - R_Mesh_TexCoordPointer(1, 3, GL_FLOAT , sizeof(*vertex), vertex->svector3f , NULL, 0); - R_Mesh_TexCoordPointer(2, 3, GL_FLOAT , sizeof(*vertex), vertex->tvector3f , NULL, 0); - R_Mesh_TexCoordPointer(3, 4, GL_FLOAT , sizeof(*vertex), vertex->normal3f , NULL, 0); - R_Mesh_TexCoordPointer(4, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0); - break; - case RENDERPATH_GL13: - R_Mesh_TexCoordPointer(1, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0); - case RENDERPATH_GL11: - R_Mesh_VertexPointer( 3, GL_FLOAT , sizeof(*vertex), vertex->vertex3f , NULL, 0); - R_Mesh_ColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub , NULL, 0); - R_Mesh_TexCoordPointer(0, 2, GL_FLOAT , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0); - break; } }