#include "varray.h"
#include "viewport.h"
#include "mtypes.h"
-#include "main/dispatch.h"
+#include "state.h"
#include "hash.h"
#include <stdbool.h>
/* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */
GLboolean sRGBEnabled;
+
+ /* GL_NV_conservative_raster */
+ GLboolean ConservativeRasterization;
};
};
+struct viewport_state
+{
+ struct gl_viewport_attrib ViewportArray[MAX_VIEWPORTS];
+ GLuint SubpixelPrecisionBias[2];
+};
+
+
/** An unused GL_*_BIT value */
#define DUMMY_BIT 0x10000000
attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne;
attr->SampleCoverage = ctx->Multisample.SampleCoverage;
for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
- attr->Texture[i] = ctx->Texture.Unit[i].Enabled;
- attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled;
+ attr->Texture[i] = ctx->Texture.FixedFuncUnit[i].Enabled;
+ attr->TexGen[i] = ctx->Texture.FixedFuncUnit[i].TexGenEnabled;
}
/* GL_ARB_vertex_program */
attr->VertexProgram = ctx->VertexProgram.Enabled;
/* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */
attr->sRGBEnabled = ctx->Color.sRGBEnabled;
+
+ /* GL_NV_conservative_raster */
+ attr->ConservativeRasterization = ctx->ConservativeRasterization;
}
if (mask & GL_EVAL_BIT) {
}
if (mask & GL_VIEWPORT_BIT) {
- if (!push_attrib(ctx, &head, GL_VIEWPORT_BIT,
- sizeof(struct gl_viewport_attrib)
- * ctx->Const.MaxViewports,
- (void*)&ctx->ViewportArray))
+ struct viewport_state *viewstate = CALLOC_STRUCT(viewport_state);
+ if (!viewstate) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_VIEWPORT_BIT)");
goto end;
+ }
+
+ if (!save_attrib_data(&head, GL_VIEWPORT_BIT, viewstate)) {
+ free(viewstate);
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_VIEWPORT_BIT)");
+ goto end;
+ }
+
+ memcpy(&viewstate->ViewportArray, &ctx->ViewportArray,
+ sizeof(struct gl_viewport_attrib)*ctx->Const.MaxViewports);
+
+ viewstate->SubpixelPrecisionBias[0] = ctx->SubpixelPrecisionBias[0];
+ viewstate->SubpixelPrecisionBias[1] = ctx->SubpixelPrecisionBias[1];
}
/* GL_ARB_multisample */
TEST_AND_UPDATE(ctx->Color.sRGBEnabled, enable->sRGBEnabled,
GL_FRAMEBUFFER_SRGB);
+ /* GL_NV_conservative_raster */
+ if (ctx->Extensions.NV_conservative_raster) {
+ TEST_AND_UPDATE(ctx->ConservativeRasterization,
+ enable->ConservativeRasterization,
+ GL_CONSERVATIVE_RASTERIZATION_NV);
+ }
+
/* texture unit enables */
for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
const GLbitfield enabled = enable->Texture[i];
const GLbitfield genEnabled = enable->TexGen[i];
- if (ctx->Texture.Unit[i].Enabled != enabled) {
+ if (ctx->Texture.FixedFuncUnit[i].Enabled != enabled) {
_mesa_ActiveTexture(GL_TEXTURE0 + i);
_mesa_set_enable(ctx, GL_TEXTURE_1D, !!(enabled & TEXTURE_1D_BIT));
}
}
- if (ctx->Texture.Unit[i].TexGenEnabled != genEnabled) {
+ if (ctx->Texture.FixedFuncUnit[i].TexGenEnabled != genEnabled) {
_mesa_ActiveTexture(GL_TEXTURE0 + i);
_mesa_set_enable(ctx, GL_TEXTURE_GEN_S, !!(genEnabled & S_BIT));
_mesa_set_enable(ctx, GL_TEXTURE_GEN_T, !!(genEnabled & T_BIT));
_mesa_lock_context_textures(ctx);
for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
- const struct gl_texture_unit *unit = &texstate->Texture.Unit[u];
+ const struct gl_fixedfunc_texture_unit *unit =
+ &texstate->Texture.FixedFuncUnit[u];
GLuint tgt;
_mesa_ActiveTexture(GL_TEXTURE0_ARB + u);
_mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->GenQ.ObjectPlane);
/* Eye plane done differently to avoid re-transformation */
{
- struct gl_texture_unit *destUnit = &ctx->Texture.Unit[u];
+ struct gl_fixedfunc_texture_unit *destUnit =
+ &ctx->Texture.FixedFuncUnit[u];
+
COPY_4FV(destUnit->GenS.EyePlane, unit->GenS.EyePlane);
COPY_4FV(destUnit->GenT.EyePlane, unit->GenT.EyePlane);
COPY_4FV(destUnit->GenR.EyePlane, unit->GenR.EyePlane);
_mesa_set_enable(ctx, GL_TEXTURE_GEN_R, !!(unit->TexGenEnabled & R_BIT));
_mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, !!(unit->TexGenEnabled & Q_BIT));
_mesa_TexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS,
- unit->LodBias);
+ texstate->Texture.Unit[u].LodBias);
_mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,
unit->Combine.ModeRGB);
_mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,
color->ClearColor.f[3]);
_mesa_IndexMask(color->IndexMask);
if (!ctx->Extensions.EXT_draw_buffers2) {
- _mesa_ColorMask((GLboolean) (color->ColorMask[0][0] != 0),
- (GLboolean) (color->ColorMask[0][1] != 0),
- (GLboolean) (color->ColorMask[0][2] != 0),
- (GLboolean) (color->ColorMask[0][3] != 0));
+ _mesa_ColorMask(GET_COLORMASK_BIT(color->ColorMask, 0, 0),
+ GET_COLORMASK_BIT(color->ColorMask, 0, 1),
+ GET_COLORMASK_BIT(color->ColorMask, 0, 2),
+ GET_COLORMASK_BIT(color->ColorMask, 0, 3));
}
else {
GLuint i;
for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
_mesa_ColorMaski(i,
- (GLboolean) (color->ColorMask[i][0] != 0),
- (GLboolean) (color->ColorMask[i][1] != 0),
- (GLboolean) (color->ColorMask[i][2] != 0),
- (GLboolean) (color->ColorMask[i][3] != 0));
+ GET_COLORMASK_BIT(color->ColorMask, i, 0),
+ GET_COLORMASK_BIT(color->ColorMask, i, 1),
+ GET_COLORMASK_BIT(color->ColorMask, i, 2),
+ GET_COLORMASK_BIT(color->ColorMask, i, 3));
}
}
{
* user FBO bound, GL_FRONT will be illegal and we'll need
* to record that error. Per OpenGL ARB decision.
*/
- if (multipleBuffers)
- _mesa_DrawBuffers(ctx->Const.MaxDrawBuffers,
- color->DrawBuffer);
- else
+ if (multipleBuffers) {
+ GLenum buffers[MAX_DRAW_BUFFERS];
+
+ for (unsigned i = 0; i < ctx->Const.MaxDrawBuffers; i++)
+ buffers[i] = color->DrawBuffer[i];
+
+ _mesa_DrawBuffers(ctx->Const.MaxDrawBuffers, buffers);
+ } else {
_mesa_DrawBuffer(color->DrawBuffer[0]);
+ }
}
_mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled);
_mesa_AlphaFunc(color->AlphaFunc, color->AlphaRefUnclamped);
ctx->DriverFlags.NewSampleAlphaToXEnable |
ctx->DriverFlags.NewSampleMask |
ctx->DriverFlags.NewScissorTest |
- ctx->DriverFlags.NewStencil;
+ ctx->DriverFlags.NewStencil |
+ ctx->DriverFlags.NewNvConservativeRasterization;
}
break;
case GL_EVAL_BIT:
case GL_VIEWPORT_BIT:
{
unsigned i;
- const struct gl_viewport_attrib *vp;
- vp = (const struct gl_viewport_attrib *) attr->data;
+ const struct viewport_state *viewstate;
+ viewstate = (const struct viewport_state *) attr->data;
for (i = 0; i < ctx->Const.MaxViewports; i++) {
- _mesa_set_viewport(ctx, i, vp[i].X, vp[i].Y, vp[i].Width,
- vp[i].Height);
- _mesa_set_depth_range(ctx, i, vp[i].Near, vp[i].Far);
+ const struct gl_viewport_attrib *vp = &viewstate->ViewportArray[i];
+ _mesa_set_viewport(ctx, i, vp->X, vp->Y, vp->Width,
+ vp->Height);
+ _mesa_set_depth_range(ctx, i, vp->Near, vp->Far);
+ }
+
+ if (ctx->Extensions.NV_conservative_raster) {
+ GLuint biasx = viewstate->SubpixelPrecisionBias[0];
+ GLuint biasy = viewstate->SubpixelPrecisionBias[1];
+ _mesa_SubpixelPrecisionBiasNV(biasx, biasy);
}
}
break;
/* skip RefCount */
for (i = 0; i < ARRAY_SIZE(src->VertexAttrib); i++) {
- _mesa_copy_client_array(ctx, &dest->_VertexAttrib[i], &src->_VertexAttrib[i]);
_mesa_copy_vertex_attrib_array(ctx, &dest->VertexAttrib[i], &src->VertexAttrib[i]);
_mesa_copy_vertex_buffer_binding(ctx, &dest->BufferBinding[i], &src->BufferBinding[i]);
}
/* _Enabled must be the same than on push */
dest->_Enabled = src->_Enabled;
+ dest->_EffEnabledVBO = src->_EffEnabledVBO;
/* The bitmask of bound VBOs needs to match the VertexBinding array */
dest->VertexAttribBufferMask = src->VertexAttribBufferMask;
+ dest->_AttributeMapMode = src->_AttributeMapMode;
dest->NewArrays = src->NewArrays;
}
/* skip IndexBufferObj */
/* Invalidate array state. It will be updated during the next draw. */
- _mesa_set_drawing_arrays(ctx, NULL);
+ _mesa_set_draw_vao(ctx, ctx->Array._EmptyVAO, 0);
}
/**