#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 ||
ctx->DrawBuffer->_Xmin >= ctx->DrawBuffer->_Xmax ||
ctx->DrawBuffer->_Ymin >= ctx->DrawBuffer->_Ymax)
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) {
GLuint i;
for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {
bufferMask |= (1 << ctx->DrawBuffer->_ColorDrawBufferIndexes[i]);
}
}
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, const struct gl_framebuffer *fb)
{
GLbitfield mask = 0x0;
if (fb->Name > 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 (fb->Visual.stereoMode) {
mask |= BUFFER_BIT_FRONT_RIGHT;
if (fb->Visual.doubleBufferMode) {
mask |= BUFFER_BIT_BACK_LEFT | BUFFER_BIT_BACK_RIGHT;
}
}
else if (fb->Visual.doubleBufferMode) {
mask |= BUFFER_BIT_BACK_LEFT;
}
for (i = 0; i < fb->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)
{
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));
}
if (buffer == GL_NONE) {
destMask = 0x0;
}
else {
const GLbitfield supportedMask
= supported_buffer_bitmask(ctx, ctx->DrawBuffer);
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);
if (ctx->Driver.DrawBuffers)
ctx->Driver.DrawBuffers(ctx, 1, &buffer);
else if (ctx->Driver.DrawBuffer)
ctx->Driver.DrawBuffer(ctx, buffer);
}
void GLAPIENTRY
_mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers)
{
GLint output;
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;
}
supportedMask = supported_buffer_bitmask(ctx, ctx->DrawBuffer);
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);
if (ctx->Driver.DrawBuffers)
ctx->Driver.DrawBuffers(ctx, n, buffers);
else if (ctx->Driver.DrawBuffer)
ctx->Driver.DrawBuffer(ctx, buffers[0]);
}
void
_mesa_drawbuffers(GLcontext *ctx, GLuint n, const GLenum *buffers,
const GLbitfield *destMask)
{
struct gl_framebuffer *fb = ctx->DrawBuffer;
GLbitfield mask[MAX_DRAW_BUFFERS];
if (!destMask) {
const GLbitfield supportedMask = supported_buffer_bitmask(ctx, fb);
GLuint output;
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;
}
if (n == 1) {
GLuint buf, count = 0;
fb->_ColorDrawBufferIndexes[0] = -1;
for (buf = 0; buf < BUFFER_COUNT; buf++) {
if (destMask[0] & (1 << buf)) {
fb->_ColorDrawBufferIndexes[count] = buf;
count++;
}
}
fb->ColorDrawBuffer[0] = buffers[0];
fb->_NumColorDrawBuffers = count;
}
else {
GLuint buf, count = 0;
for (buf = 0; buf < n; buf++ ) {
if (destMask[buf]) {
fb->_ColorDrawBufferIndexes[buf] = _mesa_ffs(destMask[buf]) - 1;
fb->ColorDrawBuffer[buf] = buffers[buf];
count = buf + 1;
}
else {
fb->_ColorDrawBufferIndexes[buf] = -1;
}
}
while (buf < ctx->Const.MaxDrawBuffers) {
fb->_ColorDrawBufferIndexes[buf] = -1;
fb->ColorDrawBuffer[buf] = GL_NONE;
buf++;
}
fb->_NumColorDrawBuffers = count;
}
if (fb->Name == 0) {
GLuint buf;
for (buf = 0; buf < ctx->Const.MaxDrawBuffers; buf++) {
ctx->Color.DrawBuffer[buf] = fb->ColorDrawBuffer[buf];
}
}
ctx->NewState |= _NEW_COLOR;
}
void
_mesa_readbuffer(GLcontext *ctx, GLenum buffer, GLint bufferIndex)
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
if (fb->Name == 0) {
ctx->Pixel.ReadBuffer = buffer;
}
fb->ColorReadBuffer = buffer;
fb->_ColorReadBufferIndex = bufferIndex;
ctx->NewState |= _NEW_PIXEL;
}
void GLAPIENTRY
_mesa_ReadBuffer(GLenum buffer)
{
struct gl_framebuffer *fb;
GLbitfield supportedMask;
GLint srcBuffer;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glReadBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
fb = ctx->ReadBuffer;
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glReadBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
if (fb->Name > 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, fb);
if (((1 << srcBuffer) & supportedMask) == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glReadBuffer(buffer=0x%x)", buffer);
return;
}
}
_mesa_readbuffer(ctx, buffer, srcBuffer);
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_TRUE;
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;
}