mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-23 15:30:14 +01:00
5a459a036e
Define GLX_USE_APPLEGL, as config/darwin used to, to turn on specific code to use the applegl direct renderer Convert src/glx/apple/Makefile to automake Since the applegl libGL is now built by linking libappleglx into libGL, rather than by linking selected files into a special libGL: - Remove duplicate code in apple/glxreply.c and apple/apple_glx.c. This makes apple/glxreply.c empty, so remove it - Some indirect rendering code is already guarded by !GLX_USE_APPLEGL, but we need to add those guards to indirect_glx.c, indirect_init.c (via it's generator), render2.c and vertarr.c so they don't generate anything Fix and update various includes glapi_gentable.c (which is only used on darwin), should be included in shared glapi as well, to provide _glapi_create_table_from_handle() Note that neither swrast nor indirect is supported in the APPLEGL path at the moment, which makes things more complex than they need to be. More untangling is needed to allow that v2: Correct apple/Makefile.am for srcdir != builddir Signed-off-by: Jon TURNEY <jon.turney@dronecode.org.uk> Reviewed-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com> Reviewed-by: Emil Velikov <emil.l.velikov@gmail.com>
385 lines
11 KiB
C
385 lines
11 KiB
C
/*
|
|
* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
|
|
* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice including the dates of first publication and
|
|
* either this permission notice or a reference to
|
|
* http://oss.sgi.com/projects/FreeB/
|
|
* shall be included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
|
|
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of Silicon Graphics, Inc.
|
|
* shall not be used in advertising or otherwise to promote the sale, use or
|
|
* other dealings in this Software without prior written authorization from
|
|
* Silicon Graphics, Inc.
|
|
*/
|
|
|
|
#ifndef GLX_USE_APPLEGL
|
|
|
|
#include "packrender.h"
|
|
#include "indirect.h"
|
|
#include "indirect_size.h"
|
|
|
|
/*
|
|
** This file contains routines that might need to be transported as
|
|
** GLXRender or GLXRenderLarge commands, and these commands don't
|
|
** use the pixel header. See renderpix.c for those routines.
|
|
*/
|
|
|
|
void
|
|
__indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
|
|
GLint order, const GLdouble * pnts)
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
GLint k;
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
k = __glMap1d_size(target);
|
|
if (k == 0) {
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
else if (stride < k || order <= 0) {
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
compsize = k * order * __GLX_SIZE_FLOAT64;
|
|
cmdlen = 28 + compsize;
|
|
if (!gc->currentDpy)
|
|
return;
|
|
|
|
if (cmdlen <= gc->maxSmallRenderCommandSize) {
|
|
/* Use GLXRender protocol to send small command */
|
|
__GLX_BEGIN_VARIABLE(X_GLrop_Map1d, cmdlen);
|
|
__GLX_PUT_DOUBLE(4, u1);
|
|
__GLX_PUT_DOUBLE(12, u2);
|
|
__GLX_PUT_LONG(20, target);
|
|
__GLX_PUT_LONG(24, order);
|
|
/*
|
|
** NOTE: the doubles that follow are not aligned because of 3
|
|
** longs preceeding
|
|
*/
|
|
__glFillMap1d(k, order, stride, pnts, (pc + 28));
|
|
__GLX_END(cmdlen);
|
|
}
|
|
else {
|
|
/* Use GLXRenderLarge protocol to send command */
|
|
__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1d, cmdlen + 4);
|
|
__GLX_PUT_DOUBLE(8, u1);
|
|
__GLX_PUT_DOUBLE(16, u2);
|
|
__GLX_PUT_LONG(24, target);
|
|
__GLX_PUT_LONG(28, order);
|
|
|
|
/*
|
|
** NOTE: the doubles that follow are not aligned because of 3
|
|
** longs preceeding
|
|
*/
|
|
if (stride != k) {
|
|
GLubyte *buf;
|
|
|
|
buf = malloc(compsize);
|
|
if (!buf) {
|
|
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
__glFillMap1d(k, order, stride, pnts, buf);
|
|
__glXSendLargeCommand(gc, pc, 32, buf, compsize);
|
|
free((char *) buf);
|
|
}
|
|
else {
|
|
/* Data is already packed. Just send it out */
|
|
__glXSendLargeCommand(gc, pc, 32, pnts, compsize);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
__indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
|
|
GLint order, const GLfloat * pnts)
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
GLint k;
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
k = __glMap1f_size(target);
|
|
if (k == 0) {
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
else if (stride < k || order <= 0) {
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
compsize = k * order * __GLX_SIZE_FLOAT32;
|
|
cmdlen = 20 + compsize;
|
|
if (!gc->currentDpy)
|
|
return;
|
|
|
|
/*
|
|
** The order that arguments are packed is different from the order
|
|
** for glMap1d.
|
|
*/
|
|
if (cmdlen <= gc->maxSmallRenderCommandSize) {
|
|
/* Use GLXRender protocol to send small command */
|
|
__GLX_BEGIN_VARIABLE(X_GLrop_Map1f, cmdlen);
|
|
__GLX_PUT_LONG(4, target);
|
|
__GLX_PUT_FLOAT(8, u1);
|
|
__GLX_PUT_FLOAT(12, u2);
|
|
__GLX_PUT_LONG(16, order);
|
|
__glFillMap1f(k, order, stride, pnts, (GLubyte *) (pc + 20));
|
|
__GLX_END(cmdlen);
|
|
}
|
|
else {
|
|
/* Use GLXRenderLarge protocol to send command */
|
|
__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1f, cmdlen + 4);
|
|
__GLX_PUT_LONG(8, target);
|
|
__GLX_PUT_FLOAT(12, u1);
|
|
__GLX_PUT_FLOAT(16, u2);
|
|
__GLX_PUT_LONG(20, order);
|
|
|
|
if (stride != k) {
|
|
GLubyte *buf;
|
|
|
|
buf = malloc(compsize);
|
|
if (!buf) {
|
|
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
__glFillMap1f(k, order, stride, pnts, buf);
|
|
__glXSendLargeCommand(gc, pc, 24, buf, compsize);
|
|
free((char *) buf);
|
|
}
|
|
else {
|
|
/* Data is already packed. Just send it out */
|
|
__glXSendLargeCommand(gc, pc, 24, pnts, compsize);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
__indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr,
|
|
GLint uord, GLdouble v1, GLdouble v2, GLint vstr,
|
|
GLint vord, const GLdouble * pnts)
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
GLint k;
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
k = __glMap2d_size(target);
|
|
if (k == 0) {
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
compsize = k * uord * vord * __GLX_SIZE_FLOAT64;
|
|
cmdlen = 48 + compsize;
|
|
if (!gc->currentDpy)
|
|
return;
|
|
|
|
if (cmdlen <= gc->maxSmallRenderCommandSize) {
|
|
/* Use GLXRender protocol to send small command */
|
|
__GLX_BEGIN_VARIABLE(X_GLrop_Map2d, cmdlen);
|
|
__GLX_PUT_DOUBLE(4, u1);
|
|
__GLX_PUT_DOUBLE(12, u2);
|
|
__GLX_PUT_DOUBLE(20, v1);
|
|
__GLX_PUT_DOUBLE(28, v2);
|
|
__GLX_PUT_LONG(36, target);
|
|
__GLX_PUT_LONG(40, uord);
|
|
__GLX_PUT_LONG(44, vord);
|
|
/*
|
|
** Pack into a u-major ordering.
|
|
** NOTE: the doubles that follow are not aligned because of 5
|
|
** longs preceeding
|
|
*/
|
|
__glFillMap2d(k, uord, vord, ustr, vstr, pnts, (GLdouble *) (pc + 48));
|
|
__GLX_END(cmdlen);
|
|
}
|
|
else {
|
|
/* Use GLXRenderLarge protocol to send command */
|
|
__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2d, cmdlen + 4);
|
|
__GLX_PUT_DOUBLE(8, u1);
|
|
__GLX_PUT_DOUBLE(16, u2);
|
|
__GLX_PUT_DOUBLE(24, v1);
|
|
__GLX_PUT_DOUBLE(32, v2);
|
|
__GLX_PUT_LONG(40, target);
|
|
__GLX_PUT_LONG(44, uord);
|
|
__GLX_PUT_LONG(48, vord);
|
|
|
|
/*
|
|
** NOTE: the doubles that follow are not aligned because of 5
|
|
** longs preceeding
|
|
*/
|
|
if ((vstr != k) || (ustr != k * vord)) {
|
|
GLdouble *buf;
|
|
|
|
buf = malloc(compsize);
|
|
if (!buf) {
|
|
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
/*
|
|
** Pack into a u-major ordering.
|
|
*/
|
|
__glFillMap2d(k, uord, vord, ustr, vstr, pnts, buf);
|
|
__glXSendLargeCommand(gc, pc, 52, buf, compsize);
|
|
free((char *) buf);
|
|
}
|
|
else {
|
|
/* Data is already packed. Just send it out */
|
|
__glXSendLargeCommand(gc, pc, 52, pnts, compsize);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
__indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr,
|
|
GLint uord, GLfloat v1, GLfloat v2, GLint vstr, GLint vord,
|
|
const GLfloat * pnts)
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
GLint k;
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
k = __glMap2f_size(target);
|
|
if (k == 0) {
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
compsize = k * uord * vord * __GLX_SIZE_FLOAT32;
|
|
cmdlen = 32 + compsize;
|
|
if (!gc->currentDpy)
|
|
return;
|
|
|
|
/*
|
|
** The order that arguments are packed is different from the order
|
|
** for glMap2d.
|
|
*/
|
|
if (cmdlen <= gc->maxSmallRenderCommandSize) {
|
|
/* Use GLXRender protocol to send small command */
|
|
__GLX_BEGIN_VARIABLE(X_GLrop_Map2f, cmdlen);
|
|
__GLX_PUT_LONG(4, target);
|
|
__GLX_PUT_FLOAT(8, u1);
|
|
__GLX_PUT_FLOAT(12, u2);
|
|
__GLX_PUT_LONG(16, uord);
|
|
__GLX_PUT_FLOAT(20, v1);
|
|
__GLX_PUT_FLOAT(24, v2);
|
|
__GLX_PUT_LONG(28, vord);
|
|
/*
|
|
** Pack into a u-major ordering.
|
|
*/
|
|
__glFillMap2f(k, uord, vord, ustr, vstr, pnts, (GLfloat *) (pc + 32));
|
|
__GLX_END(cmdlen);
|
|
}
|
|
else {
|
|
/* Use GLXRenderLarge protocol to send command */
|
|
__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2f, cmdlen + 4);
|
|
__GLX_PUT_LONG(8, target);
|
|
__GLX_PUT_FLOAT(12, u1);
|
|
__GLX_PUT_FLOAT(16, u2);
|
|
__GLX_PUT_LONG(20, uord);
|
|
__GLX_PUT_FLOAT(24, v1);
|
|
__GLX_PUT_FLOAT(28, v2);
|
|
__GLX_PUT_LONG(32, vord);
|
|
|
|
if ((vstr != k) || (ustr != k * vord)) {
|
|
GLfloat *buf;
|
|
|
|
buf = malloc(compsize);
|
|
if (!buf) {
|
|
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
/*
|
|
** Pack into a u-major ordering.
|
|
*/
|
|
__glFillMap2f(k, uord, vord, ustr, vstr, pnts, buf);
|
|
__glXSendLargeCommand(gc, pc, 36, buf, compsize);
|
|
free((char *) buf);
|
|
}
|
|
else {
|
|
/* Data is already packed. Just send it out */
|
|
__glXSendLargeCommand(gc, pc, 36, pnts, compsize);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
__indirect_glEnable(GLenum cap)
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
if (!gc->currentDpy)
|
|
return;
|
|
|
|
switch (cap) {
|
|
case GL_COLOR_ARRAY:
|
|
case GL_EDGE_FLAG_ARRAY:
|
|
case GL_INDEX_ARRAY:
|
|
case GL_NORMAL_ARRAY:
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
case GL_VERTEX_ARRAY:
|
|
case GL_SECONDARY_COLOR_ARRAY:
|
|
case GL_FOG_COORD_ARRAY:
|
|
__indirect_glEnableClientState(cap);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
__GLX_BEGIN(X_GLrop_Enable, 8);
|
|
__GLX_PUT_LONG(4, cap);
|
|
__GLX_END(8);
|
|
}
|
|
|
|
void
|
|
__indirect_glDisable(GLenum cap)
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
if (!gc->currentDpy)
|
|
return;
|
|
|
|
switch (cap) {
|
|
case GL_COLOR_ARRAY:
|
|
case GL_EDGE_FLAG_ARRAY:
|
|
case GL_INDEX_ARRAY:
|
|
case GL_NORMAL_ARRAY:
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
case GL_VERTEX_ARRAY:
|
|
case GL_SECONDARY_COLOR_ARRAY:
|
|
case GL_FOG_COORD_ARRAY:
|
|
__indirect_glDisableClientState(cap);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
__GLX_BEGIN(X_GLrop_Disable, 8);
|
|
__GLX_PUT_LONG(4, cap);
|
|
__GLX_END(8);
|
|
}
|
|
|
|
#endif
|