#include "glheader.h"
#include "buffers.h"
#include "colormac.h"
#include "context.h"
#include "enums.h"
#include "fbobject.h"
#include "state.h"
#define BAD_MASK ~0u
#if _HAVE_FULL_GL
void GLAPIENTRY
_mesa_ClearIndex( GLfloat c )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (ctx->Color.ClearIndex == (GLuint) c)
return;
FLUSH_VERTICES(ctx, _NEW_COLOR);
ctx->Color.ClearIndex = (GLuint) c;
if (!ctx->Visual.rgbMode && ctx->Driver.ClearIndex) {
(*ctx->Driver.ClearIndex)( ctx, ctx->Color.ClearIndex );
}
}
#endif
void GLAPIENTRY
_mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
{
GLfloat tmp[4];
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
tmp[0] = CLAMP(red, 0.0F, 1.0F);
tmp[1] = CLAMP(green, 0.0F, 1.0F);
tmp[2] = CLAMP(blue, 0.0F, 1.0F);
tmp[3] = CLAMP(alpha, 0.0F, 1.0F);
if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
return;
FLUSH_VERTICES(ctx, _NEW_COLOR);
COPY_4V(ctx->Color.ClearColor, tmp);
if (ctx->Visual.rgbMode && ctx->Driver.ClearColor) {
(*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
}
}
void GLAPIENTRY
_mesa_Clear( GLbitfield mask )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glClear 0x%x\n", mask);
if (mask & ~(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT |
GL_STENCIL_BUFFER_BIT |
GL_ACCUM_BUFFER_BIT)) {
_mesa_error( ctx, GL_INVALID_VALUE, "glClear(0x%x)", mask);
return;
}
if (ctx->NewState) {
_mesa_update_state( ctx );
}
if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"glClear(incomplete framebuffer)");
return;
}
if (ctx->DrawBuffer->Width == 0 || ctx->DrawBuffer->Height == 0)
return;
if (ctx->RenderMode == GL_RENDER) {
GLbitfield bufferMask;
if (!ctx->Depth.Mask)
mask &= ~GL_DEPTH_BUFFER_BIT;
bufferMask = 0;
if (mask & GL_COLOR_BUFFER_BIT) {
bufferMask |= ctx->DrawBuffer->_ColorDrawBufferMask[0];
}
if ((mask & GL_DEPTH_BUFFER_BIT)
&& ctx->DrawBuffer->Visual.haveDepthBuffer) {
bufferMask |= BUFFER_BIT_DEPTH;
}
if ((mask & GL_STENCIL_BUFFER_BIT)
&& ctx->DrawBuffer->Visual.haveStencilBuffer) {
bufferMask |= BUFFER_BIT_STENCIL;
}
if ((mask & GL_ACCUM_BUFFER_BIT)
&& ctx->DrawBuffer->Visual.haveAccumBuffer) {
bufferMask |= BUFFER_BIT_ACCUM;
}
ASSERT(ctx->Driver.Clear);
ctx->Driver.Clear(ctx, bufferMask);
}
}
static GLbitfield
supported_buffer_bitmask(const GLcontext *ctx, GLuint framebufferID)
{
GLbitfield mask = 0x0;
if (framebufferID > 0) {
GLuint i;
ASSERT(ctx->Extensions.EXT_framebuffer_object);
for (i = 0; i < ctx->Const.MaxColorAttachments; i++) {
mask |= (BUFFER_BIT_COLOR0 << i);
}
}
else {
GLint i;
mask = BUFFER_BIT_FRONT_LEFT;
if (ctx->Visual.stereoMode) {
mask |= BUFFER_BIT_FRONT_RIGHT;
if (ctx->Visual.doubleBufferMode) {
mask |= BUFFER_BIT_BACK_LEFT | BUFFER_BIT_BACK_RIGHT;
}
}
else if (ctx->Visual.doubleBufferMode) {
mask |= BUFFER_BIT_BACK_LEFT;
}
for (i = 0; i < ctx->Visual.numAuxBuffers; i++) {
mask |= (BUFFER_BIT_AUX0 << i);
}
}
return mask;
}
static GLbitfield
draw_buffer_enum_to_bitmask(GLenum buffer)
{
switch (buffer) {
case GL_NONE:
return 0;
case GL_FRONT:
return BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_FRONT_RIGHT;
case GL_BACK:
return BUFFER_BIT_BACK_LEFT | BUFFER_BIT_BACK_RIGHT;
case GL_RIGHT:
return BUFFER_BIT_FRONT_RIGHT | BUFFER_BIT_BACK_RIGHT;
case GL_FRONT_RIGHT:
return BUFFER_BIT_FRONT_RIGHT;
case GL_BACK_RIGHT:
return BUFFER_BIT_BACK_RIGHT;
case GL_BACK_LEFT:
return BUFFER_BIT_BACK_LEFT;
case GL_FRONT_AND_BACK:
return BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT
| BUFFER_BIT_FRONT_RIGHT | BUFFER_BIT_BACK_RIGHT;
case GL_LEFT:
return BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT;
case GL_FRONT_LEFT:
return BUFFER_BIT_FRONT_LEFT;
case GL_AUX0:
return BUFFER_BIT_AUX0;
case GL_AUX1:
return BUFFER_BIT_AUX1;
case GL_AUX2:
return BUFFER_BIT_AUX2;
case GL_AUX3:
return BUFFER_BIT_AUX3;
case GL_COLOR_ATTACHMENT0_EXT:
return BUFFER_BIT_COLOR0;
case GL_COLOR_ATTACHMENT1_EXT:
return BUFFER_BIT_COLOR1;
case GL_COLOR_ATTACHMENT2_EXT:
return BUFFER_BIT_COLOR2;
case GL_COLOR_ATTACHMENT3_EXT:
return BUFFER_BIT_COLOR3;
case GL_COLOR_ATTACHMENT4_EXT:
return BUFFER_BIT_COLOR4;
case GL_COLOR_ATTACHMENT5_EXT:
return BUFFER_BIT_COLOR5;
case GL_COLOR_ATTACHMENT6_EXT:
return BUFFER_BIT_COLOR6;
case GL_COLOR_ATTACHMENT7_EXT:
return BUFFER_BIT_COLOR7;
default:
return BAD_MASK;
}
}
static GLint
read_buffer_enum_to_index(GLenum buffer)
{
switch (buffer) {
case GL_FRONT:
return BUFFER_FRONT_LEFT;
case GL_BACK:
return BUFFER_BACK_LEFT;
case GL_RIGHT:
return BUFFER_FRONT_RIGHT;
case GL_FRONT_RIGHT:
return BUFFER_FRONT_RIGHT;
case GL_BACK_RIGHT:
return BUFFER_BACK_RIGHT;
case GL_BACK_LEFT:
return BUFFER_BACK_LEFT;
case GL_LEFT:
return BUFFER_FRONT_LEFT;
case GL_FRONT_LEFT:
return BUFFER_FRONT_LEFT;
case GL_AUX0:
return BUFFER_AUX0;
case GL_AUX1:
return BUFFER_AUX1;
case GL_AUX2:
return BUFFER_AUX2;
case GL_AUX3:
return BUFFER_AUX3;
case GL_COLOR_ATTACHMENT0_EXT:
return BUFFER_COLOR0;
case GL_COLOR_ATTACHMENT1_EXT:
return BUFFER_COLOR1;
case GL_COLOR_ATTACHMENT2_EXT:
return BUFFER_COLOR2;
case GL_COLOR_ATTACHMENT3_EXT:
return BUFFER_COLOR3;
case GL_COLOR_ATTACHMENT4_EXT:
return BUFFER_COLOR4;
case GL_COLOR_ATTACHMENT5_EXT:
return BUFFER_COLOR5;
case GL_COLOR_ATTACHMENT6_EXT:
return BUFFER_COLOR6;
case GL_COLOR_ATTACHMENT7_EXT:
return BUFFER_COLOR7;
default:
return -1;
}
}
void GLAPIENTRY
_mesa_DrawBuffer(GLenum buffer)
{
GLuint bufferID;
GLbitfield destMask;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (MESA_VERBOSE & VERBOSE_API) {
_mesa_debug(ctx, "glDrawBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
}
bufferID = ctx->DrawBuffer->Name;
if (buffer == GL_NONE) {
destMask = 0x0;
}
else {
const GLbitfield supportedMask = supported_buffer_bitmask(ctx, bufferID);
destMask = draw_buffer_enum_to_bitmask(buffer);
if (destMask == BAD_MASK) {
_mesa_error(ctx, GL_INVALID_ENUM, "glDrawBuffer(buffer)");
return;
}
destMask &= supportedMask;
if (destMask == 0x0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glDrawBuffer(buffer)");
return;
}
}
_mesa_drawbuffers(ctx, 1, &buffer, &destMask);
}
void GLAPIENTRY
_mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers)
{
GLint output;
GLuint bufferID;
GLbitfield usedBufferMask, supportedMask;
GLbitfield destMask[MAX_DRAW_BUFFERS];
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (!ctx->Extensions.ARB_draw_buffers) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glDrawBuffersARB");
return;
}
if (n < 1 || n > (GLsizei) ctx->Const.MaxDrawBuffers) {
_mesa_error(ctx, GL_INVALID_VALUE, "glDrawBuffersARB(n)");
return;
}
bufferID = ctx->DrawBuffer->Name;
supportedMask = supported_buffer_bitmask(ctx, bufferID);
usedBufferMask = 0x0;
for (output = 0; output < n; output++) {
if (buffers[output] == GL_NONE) {
destMask[output] = 0x0;
}
else {
destMask[output] = draw_buffer_enum_to_bitmask(buffers[output]);
if (destMask[output] == BAD_MASK
|| _mesa_bitcount(destMask[output]) > 1) {
_mesa_error(ctx, GL_INVALID_ENUM, "glDrawBuffersARB(buffer)");
return;
}
destMask[output] &= supportedMask;
if (destMask[output] == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawBuffersARB(unsupported buffer)");
return;
}
if (destMask[output] & usedBufferMask) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawBuffersARB(duplicated buffer)");
return;
}
usedBufferMask |= destMask[output];
}
}
_mesa_drawbuffers(ctx, n, buffers, destMask);
}
static void
set_color_output(GLcontext *ctx, GLuint output, GLenum buffer,
GLbitfield destMask)
{
struct gl_framebuffer *fb = ctx->DrawBuffer;
ASSERT(output < ctx->Const.MaxDrawBuffers);
fb->ColorDrawBuffer[output] = buffer;
fb->_ColorDrawBufferMask[output] = destMask;
fb->_NumColorDrawBuffers[output] = 0;
ctx->Color.DrawBuffer[output] = buffer;
}
void
_mesa_drawbuffers(GLcontext *ctx, GLuint n, const GLenum *buffers,
const GLbitfield *destMask)
{
GLbitfield mask[MAX_DRAW_BUFFERS];
GLuint output;
if (!destMask) {
const GLuint bufferID = ctx->DrawBuffer->Name;
const GLbitfield supportedMask = supported_buffer_bitmask(ctx, bufferID);
for (output = 0; output < n; output++) {
mask[output] = draw_buffer_enum_to_bitmask(buffers[output]);
ASSERT(mask[output] != BAD_MASK);
mask[output] &= supportedMask;
}
destMask = mask;
}
for (output = 0; output < n; output++) {
set_color_output(ctx, output, buffers[output], destMask[output]);
}
for (output = n; output < ctx->Const.MaxDrawBuffers; output++) {
set_color_output(ctx, output, GL_NONE, 0x0);
}
ctx->NewState |= _NEW_COLOR;
if (ctx->Driver.DrawBuffers)
ctx->Driver.DrawBuffers(ctx, n, buffers);
else if (ctx->Driver.DrawBuffer)
ctx->Driver.DrawBuffer(ctx, buffers[0]);
}
void GLAPIENTRY
_mesa_ReadBuffer(GLenum buffer)
{
struct gl_framebuffer *fb;
GLbitfield supportedMask;
GLint srcBuffer;
GLuint bufferID;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
fb = ctx->ReadBuffer;
bufferID = fb->Name;
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glReadBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
if (bufferID > 0 && buffer == GL_NONE) {
srcBuffer = -1;
}
else {
srcBuffer = read_buffer_enum_to_index(buffer);
if (srcBuffer == -1) {
_mesa_error(ctx, GL_INVALID_ENUM, "glReadBuffer(buffer=0x%x)", buffer);
return;
}
supportedMask = supported_buffer_bitmask(ctx, bufferID);
if (((1 << srcBuffer) & supportedMask) == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glReadBuffer(buffer=0x%x)", buffer);
return;
}
}
if (bufferID == 0) {
ctx->Pixel.ReadBuffer = buffer;
}
fb->ColorReadBuffer = buffer;
fb->_ColorReadBufferIndex = srcBuffer;
ctx->NewState |= _NEW_PIXEL;
if (ctx->Driver.ReadBuffer)
(*ctx->Driver.ReadBuffer)(ctx, buffer);
}
#if _HAVE_FULL_GL
void _mesa_resizebuffers( GLcontext *ctx )
{
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glResizeBuffersMESA\n");
if (!ctx->Driver.GetBufferSize) {
return;
}
if (ctx->WinSysDrawBuffer) {
GLuint newWidth, newHeight;
GLframebuffer *buffer = ctx->WinSysDrawBuffer;
assert(buffer->Name == 0);
ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );
if (buffer->Width != newWidth || buffer->Height != newHeight) {
if (ctx->Driver.ResizeBuffers)
ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );
}
}
if (ctx->WinSysReadBuffer
&& ctx->WinSysReadBuffer != ctx->WinSysDrawBuffer) {
GLuint newWidth, newHeight;
GLframebuffer *buffer = ctx->WinSysReadBuffer;
assert(buffer->Name == 0);
ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );
if (buffer->Width != newWidth || buffer->Height != newHeight) {
if (ctx->Driver.ResizeBuffers)
ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );
}
}
ctx->NewState |= _NEW_BUFFERS;
}
void GLAPIENTRY
_mesa_ResizeBuffersMESA( void )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx->Extensions.MESA_resize_buffers)
_mesa_resizebuffers( ctx );
}
void GLAPIENTRY
_mesa_SampleCoverageARB(GLclampf value, GLboolean invert)
{
GET_CURRENT_CONTEXT(ctx);
if (!ctx->Extensions.ARB_multisample) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glSampleCoverageARB");
return;
}
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
ctx->Multisample.SampleCoverageValue = (GLfloat) CLAMP(value, 0.0, 1.0);
ctx->Multisample.SampleCoverageInvert = invert;
ctx->NewState |= _NEW_MULTISAMPLE;
}
#endif
void
_mesa_set_scissor(GLcontext *ctx,
GLint x, GLint y, GLsizei width, GLsizei height)
{
if (x == ctx->Scissor.X &&
y == ctx->Scissor.Y &&
width == ctx->Scissor.Width &&
height == ctx->Scissor.Height)
return;
FLUSH_VERTICES(ctx, _NEW_SCISSOR);
ctx->Scissor.X = x;
ctx->Scissor.Y = y;
ctx->Scissor.Width = width;
ctx->Scissor.Height = height;
if (ctx->Driver.Scissor)
ctx->Driver.Scissor( ctx, x, y, width, height );
}
void GLAPIENTRY
_mesa_Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glScissor" );
return;
}
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glScissor %d %d %d %d\n", x, y, width, height);
_mesa_set_scissor(ctx, x, y, width, height);
}
void
_mesa_init_scissor(GLcontext *ctx)
{
ctx->Scissor.Enabled = GL_FALSE;
ctx->Scissor.X = 0;
ctx->Scissor.Y = 0;
ctx->Scissor.Width = 0;
ctx->Scissor.Height = 0;
}
void
_mesa_init_multisample(GLcontext *ctx)
{
ctx->Multisample.Enabled = GL_FALSE;
ctx->Multisample.SampleAlphaToCoverage = GL_FALSE;
ctx->Multisample.SampleAlphaToOne = GL_FALSE;
ctx->Multisample.SampleCoverage = GL_FALSE;
ctx->Multisample.SampleCoverageValue = 1.0;
ctx->Multisample.SampleCoverageInvert = GL_FALSE;
}