#include "main/simple_list.h"
#include "main/api_arrayelt.h"
+#include "drivers/common/meta.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
-#include "shader/prog_parameter.h"
-#include "shader/prog_statevars.h"
+#include "program/prog_parameter.h"
+#include "program/prog_statevars.h"
#include "vbo/vbo.h"
#include "tnl/tnl.h"
-#include "tnl/t_vp_build.h"
#include "r300_context.h"
#include "r300_state.h"
#include "r300_reg.h"
#include "r300_emit.h"
-#include "r300_tex.h"
#include "r300_fragprog_common.h"
#include "r300_render.h"
#include "r300_vertprog.h"
-#include "drirenderbuffer.h"
-
-static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
+static void r300BlendColor(struct gl_context * ctx, const GLfloat cf[4])
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
}
}
-static void r300SetBlendState(GLcontext * ctx)
+static void r300SetBlendState(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
int func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
R300_ALPHA_BLEND_ENABLE), funcA, eqnA);
}
-static void r300BlendEquationSeparate(GLcontext * ctx,
+static void r300BlendEquationSeparate(struct gl_context * ctx,
GLenum modeRGB, GLenum modeA)
{
r300SetBlendState(ctx);
}
-static void r300BlendFuncSeparate(GLcontext * ctx,
+static void r300BlendFuncSeparate(struct gl_context * ctx,
GLenum sfactorRGB, GLenum dfactorRGB,
GLenum sfactorA, GLenum dfactorA)
{
* Used internally to update the r300->hw hardware state to match the
* current OpenGL state.
*/
-static void r300SetLogicOpState(GLcontext *ctx)
+static void r300SetLogicOpState(struct gl_context *ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
R300_STATECHANGE(r300, rop);
* Called by Mesa when an application program changes the LogicOp state
* via glLogicOp.
*/
-static void r300LogicOpcode(GLcontext *ctx, GLenum logicop)
+static void r300LogicOpcode(struct gl_context *ctx, GLenum logicop)
{
if (RGBA_LOGICOP_ENABLED(ctx))
r300SetLogicOpState(ctx);
}
-static void r300ClipPlane( GLcontext *ctx, GLenum plane, const GLfloat *eq )
+static void r300ClipPlane( struct gl_context *ctx, GLenum plane, const GLfloat *eq )
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
GLint p;
p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
ip = (GLint *)ctx->Transform._ClipUserPlane[p];
- R300_STATECHANGE( rmesa, vap_flush );
R300_STATECHANGE( rmesa, vpucp[p] );
rmesa->hw.vpucp[p].cmd[R300_VPUCP_X] = ip[0];
rmesa->hw.vpucp[p].cmd[R300_VPUCP_Y] = ip[1];
rmesa->hw.vpucp[p].cmd[R300_VPUCP_W] = ip[3];
}
-static void r300SetClipPlaneState(GLcontext * ctx, GLenum cap, GLboolean state)
+static void r300SetClipPlaneState(struct gl_context * ctx, GLenum cap, GLboolean state)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
GLuint p;
/**
* Update our tracked culling state based on Mesa's state.
*/
-static void r300UpdateCulling(GLcontext * ctx)
+static void r300UpdateCulling(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
uint32_t val = 0;
r300->hw.cul.cmd[R300_CUL_CULL] = val;
}
-static void r300SetPolygonOffsetState(GLcontext * ctx, GLboolean state)
+static void r300SetPolygonOffsetState(struct gl_context * ctx, GLboolean state)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
}
}
-static GLboolean current_fragment_program_writes_depth(GLcontext* ctx)
+static GLboolean current_fragment_program_writes_depth(struct gl_context* ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
return ctx->FragmentProgram._Current && r300->selected_fp->code.writes_depth;
}
-static void r300SetEarlyZState(GLcontext * ctx)
+static void r300SetEarlyZState(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
GLuint topZ = R300_ZTOP_ENABLE;
}
}
-static void r300SetAlphaState(GLcontext * ctx)
+static void r300SetAlphaState(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
GLubyte refByte;
r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
}
-static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
+static void r300AlphaFunc(struct gl_context * ctx, GLenum func, GLfloat ref)
{
(void)func;
(void)ref;
return 0;
}
-static void r300SetDepthState(GLcontext * ctx)
+static void r300SetDepthState(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
R500_STENCIL_REFMASK_FRONT_BACK);
r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_Z_FUNC_SHIFT);
- if (ctx->Depth.Test) {
+ if (ctx->Depth.Test && ctx->DrawBuffer->_DepthBuffer) {
r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_Z_ENABLE;
if (ctx->Depth.Mask)
r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_Z_WRITE_ENABLE;
}
}
-static void r300CatchStencilFallback(GLcontext *ctx)
+static void r300CatchStencilFallback(struct gl_context *ctx)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
const unsigned back = ctx->Stencil._BackFace;
}
}
-static void r300SetStencilState(GLcontext * ctx, GLboolean state)
+static void r300SetStencilState(struct gl_context * ctx, GLboolean state)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
GLboolean hw_stencil = GL_FALSE;
}
}
-static void r300UpdatePolygonMode(GLcontext * ctx)
+static void r300UpdatePolygonMode(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
uint32_t hw_mode = R300_GA_POLY_MODE_DISABLE;
*
* \note Mesa already filters redundant calls to this function.
*/
-static void r300CullFace(GLcontext * ctx, GLenum mode)
+static void r300CullFace(struct gl_context * ctx, GLenum mode)
{
(void)mode;
*
* \note Mesa already filters redundant calls to this function.
*/
-static void r300FrontFace(GLcontext * ctx, GLenum mode)
+static void r300FrontFace(struct gl_context * ctx, GLenum mode)
{
(void)mode;
*
* \note Mesa already filters redundant calls to this function.
*/
-static void r300DepthFunc(GLcontext * ctx, GLenum func)
+static void r300DepthFunc(struct gl_context * ctx, GLenum func)
{
(void)func;
r300SetDepthState(ctx);
*
* \note Mesa already filters redundant calls to this function.
*/
-static void r300DepthMask(GLcontext * ctx, GLboolean mask)
+static void r300DepthMask(struct gl_context * ctx, GLboolean mask)
{
(void)mask;
r300SetDepthState(ctx);
/**
* Handle glColorMask()
*/
-static void r300ColorMask(GLcontext * ctx,
+static void r300ColorMask(struct gl_context * ctx,
GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
/* =============================================================
* Point state
*/
-static void r300PointSize(GLcontext * ctx, GLfloat size)
+static void r300PointSize(struct gl_context * ctx, GLfloat size)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
((int)(size * 6) << R300_POINTSIZE_Y_SHIFT);
}
-static void r300PointParameter(GLcontext * ctx, GLenum pname, const GLfloat * param)
+static void r300PointParameter(struct gl_context * ctx, GLenum pname, const GLfloat * param)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
R300_STATECHANGE(r300, ga_point_minmax);
r300->hw.ga_point_minmax.cmd[1] &= ~R300_GA_POINT_MINMAX_MIN_MASK;
r300->hw.ga_point_minmax.cmd[1] |= (GLuint)(ctx->Point.MinSize * 6.0);
+ r300PointSize(ctx, ctx->Point.Size);
break;
case GL_POINT_SIZE_MAX:
R300_STATECHANGE(r300, ga_point_minmax);
r300->hw.ga_point_minmax.cmd[1] &= ~R300_GA_POINT_MINMAX_MAX_MASK;
r300->hw.ga_point_minmax.cmd[1] |= (GLuint)(ctx->Point.MaxSize * 6.0)
<< R300_GA_POINT_MINMAX_MAX_SHIFT;
+ r300PointSize(ctx, ctx->Point.Size);
break;
case GL_POINT_DISTANCE_ATTENUATION:
break;
/* =============================================================
* Line state
*/
-static void r300LineWidth(GLcontext * ctx, GLfloat widthf)
+static void r300LineWidth(struct gl_context * ctx, GLfloat widthf)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
R300_LINE_CNT_HO | R300_LINE_CNT_VE | (int)(widthf * 6.0);
}
-static void r300PolygonMode(GLcontext * ctx, GLenum face, GLenum mode)
+static void r300PolygonMode(struct gl_context * ctx, GLenum face, GLenum mode)
{
(void)face;
(void)mode;
return 0;
}
-static void r300ShadeModel(GLcontext * ctx, GLenum mode)
+static void r300ShadeModel(struct gl_context * ctx, GLenum mode)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
rmesa->hw.shade2.cmd[3] = 0x00000000;
}
-static void r300StencilFuncSeparate(GLcontext * ctx, GLenum face,
+static void r300StencilFuncSeparate(struct gl_context * ctx, GLenum face,
GLenum func, GLint ref, GLuint mask)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
}
}
-static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
+static void r300StencilMaskSeparate(struct gl_context * ctx, GLenum face, GLuint mask)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
const unsigned back = ctx->Stencil._BackFace;
}
}
-static void r300StencilOpSeparate(GLcontext * ctx, GLenum face,
+static void r300StencilOpSeparate(struct gl_context * ctx, GLenum face,
GLenum fail, GLenum zfail, GLenum zpass)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
* Window position and viewport transformation
*/
-static void r300UpdateWindow(GLcontext * ctx)
+static void r300UpdateWindow(struct gl_context * ctx)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
- __DRIdrawablePrivate *dPriv = radeon_get_drawable(&rmesa->radeon);
+ __DRIdrawable *dPriv = radeon_get_drawable(&rmesa->radeon);
GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
const GLfloat *v = ctx->Viewport._WindowMap.m;
rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
}
-static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
+static void r300Viewport(struct gl_context * ctx, GLint x, GLint y,
GLsizei width, GLsizei height)
{
/* Don't pipeline viewport changes, conflict with window offset
radeon_viewport(ctx, x, y, width, height);
}
-static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
+static void r300DepthRange(struct gl_context * ctx, GLclampd nearval, GLclampd farval)
{
r300UpdateWindow(ctx);
}
-void r300UpdateViewportOffset(GLcontext * ctx)
+void r300UpdateViewportOffset(struct gl_context * ctx)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
- __DRIdrawablePrivate *dPriv = radeon_get_drawable(&rmesa->radeon);
+ __DRIdrawable *dPriv = radeon_get_drawable(&rmesa->radeon);
GLfloat xoffset = (GLfloat) dPriv->x;
GLfloat yoffset = (GLfloat) dPriv->y + dPriv->h;
const GLfloat *v = ctx->Viewport._WindowMap.m;
* Update R300's own internal state parameters.
* For now just STATE_R300_WINDOW_DIMENSION
*/
-static void r300UpdateStateParameters(GLcontext * ctx, GLuint new_state)
+static void r300UpdateStateParameters(struct gl_context * ctx, GLuint new_state)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
struct gl_program_parameter_list *paramList;
/* =============================================================
* Polygon state
*/
-static void r300PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units)
+static void r300PolygonOffset(struct gl_context * ctx, GLfloat factor, GLfloat units)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
GLfloat constant = units;
return f;
}
-static void r300SetupFragmentShaderTextures(GLcontext *ctx, int *tmu_mappings)
+static void r300SetupFragmentShaderTextures(struct gl_context *ctx, int *tmu_mappings)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
int i;
R300_US_TEX_INST_0, code->tex.length);
}
-static void r500SetupFragmentShaderTextures(GLcontext *ctx, int *tmu_mappings)
+static void r500SetupFragmentShaderTextures(struct gl_context *ctx, int *tmu_mappings)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
int i;
}
-static void r300SetupTextures(GLcontext * ctx)
+static void r300SetupTextures(struct gl_context * ctx)
{
int i, mtu;
struct radeon_tex_obj *t;
((hw_tcl_on) ? (ow).vp_outputs & (1 << (vp_result)) : \
RENDERINPUTS_TEST( (ow.index_bitset), (tnl_attrib) ))
-static void r300SetupRSUnit(GLcontext * ctx)
+static void r300SetupRSUnit(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
union r300_outputs_written OutputsWritten;
WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
}
-static void r500SetupRSUnit(GLcontext * ctx)
+static void r500SetupRSUnit(struct gl_context * ctx)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
union r300_outputs_written OutputsWritten;
(5 << R300_PVS_NUM_CNTLRS_SHIFT) |
(5 << R300_VF_MAX_VTX_NUM_SHIFT));
- if (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV515)
- rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (2 << R300_PVS_NUM_FPUS_SHIFT);
- else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV530) ||
- (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV560) ||
- (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV570))
+ if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R300) ||
+ (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R350))
+ rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (4 << R300_PVS_NUM_FPUS_SHIFT);
+ else if (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV530)
rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (5 << R300_PVS_NUM_FPUS_SHIFT);
else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV410) ||
(rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R420))
rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (6 << R300_PVS_NUM_FPUS_SHIFT);
else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R520) ||
- (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R580))
+ (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R580) ||
+ (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV560) ||
+ (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV570))
rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (8 << R300_PVS_NUM_FPUS_SHIFT);
else
- rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (4 << R300_PVS_NUM_FPUS_SHIFT);
+ rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (2 << R300_PVS_NUM_FPUS_SHIFT);
}
*
* \note Mesa already filters redundant calls to this function.
*/
-static void r300Enable(GLcontext * ctx, GLenum cap, GLboolean state)
+static void r300Enable(struct gl_context * ctx, GLenum cap, GLboolean state)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
if (RADEON_DEBUG & RADEON_STATE)
*/
static void r300ResetHwState(r300ContextPtr r300)
{
- GLcontext *ctx = r300->radeon.glCtx;
+ struct gl_context *ctx = r300->radeon.glCtx;
int has_tcl;
has_tcl = r300->options.hw_tcl_enabled;
if (RADEON_DEBUG & RADEON_STATE)
fprintf(stderr, "%s\n", __FUNCTION__);
- radeon_firevertices(&r300->radeon);
-
r300ColorMask(ctx,
ctx->Color.ColorMask[0][RCOMP],
ctx->Color.ColorMask[0][GCOMP],
void r300UpdateShaders(r300ContextPtr rmesa)
{
- GLcontext *ctx = rmesa->radeon.glCtx;
+ struct gl_context *ctx = rmesa->radeon.glCtx;
/* should only happenen once, just after context is created */
/* TODO: shouldn't we fallback to sw here? */
if (!ctx->FragmentProgram._Current) {
- _mesa_fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
+ fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
return;
}
if (rmesa->options.hw_tcl_enabled) {
struct r300_vertex_program *vp;
- if (rmesa->radeon.NewGLState) {
- int i;
- for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
- rmesa->temp_attrib[i] =
- TNL_CONTEXT(ctx)->vb.AttribPtr[i];
- TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
- &rmesa->dummy_attrib[i];
- }
-
- _tnl_UpdateFixedFunctionProgram(ctx);
-
- for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
- TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
- rmesa->temp_attrib[i];
- }
- }
-
vp = r300SelectAndTranslateVertexShader(ctx);
r300SwitchFallback(ctx, R300_FALLBACK_VERTEX_PROGRAM, vp->error);
rmesa->radeon.NewGLState = 0;
}
-static const GLfloat *get_fragmentprogram_constant(GLcontext *ctx, GLuint index, GLfloat * buffer)
+static const GLfloat *get_fragmentprogram_constant(struct gl_context *ctx, GLuint index, GLfloat * buffer)
{
static const GLfloat dummy[4] = { 0, 0, 0, 0 };
r300ContextPtr rmesa = R300_CONTEXT(ctx);
}
case RC_STATE_R300_WINDOW_DIMENSION: {
- __DRIdrawablePrivate * drawable = radeon_get_drawable(&rmesa->radeon);
+ __DRIdrawable * drawable = radeon_get_drawable(&rmesa->radeon);
buffer[0] = drawable->w * 0.5f; /* width*0.5 */
buffer[1] = drawable->h * 0.5f; /* height*0.5 */
buffer[2] = 0.5F; /* for moving range [-1 1] -> [0 1] */
}
-static void r300SetupPixelShader(GLcontext *ctx)
+static void r300SetupPixelShader(struct gl_context *ctx)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
struct r300_fragment_program *fp = rmesa->selected_fp;
if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
} while(0)
-static void r500SetupPixelShader(GLcontext *ctx)
+static void r500SetupPixelShader(struct gl_context *ctx)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
struct r300_fragment_program *fp = rmesa->selected_fp;
bump_r500fp_const_count(rmesa->hw.r500fp_const.cmd, fp->code.constants.Count * 4);
}
-void r300SetupVAP(GLcontext *ctx, GLuint InputsRead, GLuint OutputsWritten)
+void r300SetupVAP(struct gl_context *ctx, GLuint InputsRead, GLuint OutputsWritten)
{
r300ContextPtr rmesa = R300_CONTEXT( ctx );
struct vertex_attribute *attrs = rmesa->vbuf.attribs;
void r300UpdateShaderStates(r300ContextPtr rmesa)
{
- GLcontext *ctx;
+ struct gl_context *ctx;
ctx = rmesa->radeon.glCtx;
/* should only happenen once, just after context is created */
}
}
+#define EASY_US_OUT_FMT(comps, c0, c1, c2, c3) \
+ (R500_OUT_FMT_##comps | R500_C0_SEL_##c0 | R500_C1_SEL_##c1 | \
+ R500_C2_SEL_##c2 | R500_C3_SEL_##c3)
+static void r300SetupUsOutputFormat(struct gl_context *ctx)
+{
+ r300ContextPtr rmesa = R300_CONTEXT(ctx);
+ uint32_t hw_format;
+ struct radeon_renderbuffer *rrb = radeon_get_colorbuffer(&rmesa->radeon);
+
+ if (!rrb) {
+ return;
+ }
+
+ switch (rrb->base.Format)
+ {
+ case MESA_FORMAT_RGBA5551:
+ case MESA_FORMAT_RGBA8888:
+ hw_format = EASY_US_OUT_FMT(C4_8, A, B, G, R);
+ break;
+ case MESA_FORMAT_RGB565_REV:
+ case MESA_FORMAT_RGBA8888_REV:
+ hw_format = EASY_US_OUT_FMT(C4_8, R, G, B, A);
+ break;
+ case MESA_FORMAT_RGB565:
+ case MESA_FORMAT_ARGB4444:
+ case MESA_FORMAT_ARGB1555:
+ case MESA_FORMAT_XRGB8888:
+ case MESA_FORMAT_ARGB8888:
+ hw_format = EASY_US_OUT_FMT(C4_8, B, G, R, A);
+ break;
+ case MESA_FORMAT_ARGB4444_REV:
+ case MESA_FORMAT_ARGB1555_REV:
+ case MESA_FORMAT_XRGB8888_REV:
+ case MESA_FORMAT_ARGB8888_REV:
+ hw_format = EASY_US_OUT_FMT(C4_8, A, R, G, B);
+ break;
+ case MESA_FORMAT_SRGBA8:
+ hw_format = EASY_US_OUT_FMT(C4_10_GAMMA, A, B, G, R);
+ break;
+ case MESA_FORMAT_SARGB8:
+ hw_format = EASY_US_OUT_FMT(C4_10_GAMMA, B, G, R, A);
+ break;
+ case MESA_FORMAT_SL8:
+ hw_format = EASY_US_OUT_FMT(C4_10_GAMMA, A, A, R, A);
+ break;
+ case MESA_FORMAT_A8:
+ hw_format = EASY_US_OUT_FMT(C4_8, A, A, A, A);
+ break;
+ case MESA_FORMAT_L8:
+ case MESA_FORMAT_I8:
+ hw_format = EASY_US_OUT_FMT(C4_8, A, A, R, A);
+ break;
+ default:
+ assert(!"Unsupported format");
+ hw_format = 0;
+ break;
+ }
+
+ R300_STATECHANGE(rmesa, us_out_fmt);
+ rmesa->hw.us_out_fmt.cmd[1] = hw_format;
+}
+#undef EASY_US_OUT_FMT
+
/**
* Called by Mesa after an internal state update.
*/
-static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
+static void r300InvalidateState(struct gl_context * ctx, GLuint new_state)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
r300->hw.shade2.cmd[1] &= ~R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST;
}
+ if (new_state & _NEW_BUFFERS) {
+ r300SetupUsOutputFormat(ctx);
+ }
+
r300->radeon.NewGLState |= new_state;
}
r300ResetHwState(r300);
}
-static void r300RenderMode(GLcontext * ctx, GLenum mode)
+static void r300RenderMode(struct gl_context * ctx, GLenum mode)
{
r300SwitchFallback(ctx, R300_FALLBACK_RENDER_MODE, ctx->RenderMode != GL_RENDER);
}
/**
* Initialize driver's state callback functions
*/
-void r300InitStateFuncs(struct dd_function_table *functions)
+void r300InitStateFuncs(radeonContextPtr radeon, struct dd_function_table *functions)
{
functions->UpdateState = r300InvalidateState;
functions->ClipPlane = r300ClipPlane;
functions->Scissor = radeonScissor;
- functions->DrawBuffer = radeonDrawBuffer;
- functions->ReadBuffer = radeonReadBuffer;
+ functions->DrawBuffer = radeonDrawBuffer;
+ functions->ReadBuffer = radeonReadBuffer;
+
+ functions->CopyPixels = _mesa_meta_CopyPixels;
+ functions->DrawPixels = _mesa_meta_DrawPixels;
+ if (radeon->radeonScreen->kernel_mm)
+ functions->ReadPixels = radeonReadPixels;
}
void r300InitShaderFunctions(r300ContextPtr r300)