自学教程：C++ DIRTY函数代码示例

void STATE_APIENTRY crStateFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *p) {	CRContext *g = GetCurrentContext();	CRClientState *c = &(g->client);	CRStateBits *sb = GetCurrentBits();	CRClientBits *cb = &(sb->client);	FLUSH();	if (type != GL_BYTE && type != GL_UNSIGNED_BYTE &&			type != GL_SHORT && type != GL_UNSIGNED_SHORT &&			type != GL_INT && type != GL_UNSIGNED_INT &&			type != GL_FLOAT && type != GL_DOUBLE)	{		crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glFogCoordPointerEXT: invalid type: 0x%x", type);		return;	}	if (stride < 0) 	{		crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glFogCoordPointerEXT: stride was negative: %d", stride);		return;	}	crStateClientSetPointer(&(c->array.f), 1, type, GL_FALSE, stride, p);	DIRTY(cb->dirty, g->neg_bitid);	DIRTY(cb->clientPointer, g->neg_bitid);	DIRTY(cb->f, g->neg_bitid);}

static inline int VAR_MATCH(struct fb_var_screeninfo *x, struct fb_var_screeninfo *y){	return (!DIRTY(bits_per_pixel) && !DIRTY(xres)		&& !DIRTY(yres) && !DIRTY(xres_virtual)		&& !DIRTY(yres_virtual)		&& !DIRTY_CMAP(red) && !DIRTY_CMAP(green) && !DIRTY_CMAP(blue));}

static voidgen8_draw_sf(struct ilo_render *r,             const struct ilo_state_vector *vec,             struct ilo_render_draw_session *session){   /* 3DSTATE_RASTER */   if (DIRTY(RASTERIZER)) {      gen8_3DSTATE_RASTER(r->builder, (vec->rasterizer) ?            &vec->rasterizer->sf : NULL);   }   /* 3DSTATE_SBE */   if (DIRTY(RASTERIZER) || DIRTY(FS)) {      gen8_3DSTATE_SBE(r->builder, vec->fs, (vec->rasterizer) ?            vec->rasterizer->state.sprite_coord_mode : 0);   }   /* 3DSTATE_SBE_SWIZ */   if (DIRTY(FS))      gen8_3DSTATE_SBE_SWIZ(r->builder, vec->fs);   /* 3DSTATE_SF */   if (DIRTY(RASTERIZER)) {      gen8_3DSTATE_SF(r->builder, (vec->rasterizer) ?            &vec->rasterizer->sf : NULL);   }}

voidgen6_draw_clip(struct ilo_render *r,               const struct ilo_state_vector *vec,               struct ilo_render_draw_session *session){   /* 3DSTATE_CLIP */   if (DIRTY(RASTERIZER) || DIRTY(FS) || DIRTY(VIEWPORT) || DIRTY(FB)) {      bool enable_guardband = true;      unsigned i;      /*       * Gen8+ has viewport extent test.  Guard band test can be enabled on       * prior Gens only when the viewport is larger than the framebuffer,       * unless we emulate viewport extent test on them.       */      if (ilo_dev_gen(r->dev) < ILO_GEN(8)) {         for (i = 0; i < vec->viewport.count; i++) {            const struct ilo_viewport_cso *vp = &vec->viewport.cso[i];            if (vp->min_x > 0.0f || vp->max_x < vec->fb.state.width ||                vp->min_y > 0.0f || vp->max_y < vec->fb.state.height) {               enable_guardband = false;               break;            }         }      }      gen6_3DSTATE_CLIP(r->builder, vec->rasterizer,            vec->fs, enable_guardband, 1);   }}

void STATE_APIENTRY crStateTexCoordPointer(GLint size, GLenum type, 		GLsizei stride, const GLvoid *p) {	CRContext *g = GetCurrentContext();	CRClientState *c = &(g->client);	CRStateBits *sb = GetCurrentBits();	CRClientBits *cb = &(sb->client);	FLUSH();	if (size != 1 && size != 2 && size != 3 && size != 4)	{		crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: invalid size: %d", size);		return;	}	if (type != GL_SHORT && type != GL_INT &&			type != GL_FLOAT && type != GL_DOUBLE)	{		crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glTexCoordPointer: invalid type: 0x%x", type);		return;	}	if (stride < 0) 	{		crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: stride was negative: %d", stride);		return;	}	crStateClientSetPointer(&(c->array.t[c->curClientTextureUnit]), size, type, GL_FALSE, stride, p);	DIRTY(cb->dirty, g->neg_bitid);	DIRTY(cb->clientPointer, g->neg_bitid);	DIRTY(cb->t[c->curClientTextureUnit], g->neg_bitid);}

void STATE_APIENTRY crStatePolygonStipple (PCRStateTracker pState, const GLubyte *p) {    CRContext *g = GetCurrentContext(pState);    CRPolygonState *poly = &(g->polygon);        CRStateBits *sb = GetCurrentBits(pState);    CRPolygonBits *pb = &(sb->polygon);    if (g->current.inBeginEnd)     {        crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION,                "glPolygonStipple called in begin/end");        return;    }    FLUSH();    if (!p && !crStateIsBufferBound(pState, GL_PIXEL_UNPACK_BUFFER_ARB))    {        crDebug("Void pointer passed to PolygonStipple");        return;    }    /** @todo track mask if buffer is bound?*/    if (!crStateIsBufferBound(pState, GL_PIXEL_UNPACK_BUFFER_ARB))    {        crMemcpy((char*)poly->stipple, (char*)p, 128);    }    DIRTY(pb->dirty, g->neg_bitid);    DIRTY(pb->stipple, g->neg_bitid);}

void STATE_APIENTRY crStatePointSize(GLfloat size) {	CRContext *g = GetCurrentContext();	CRPointState *p = &(g->point);	CRStateBits *sb = GetCurrentBits();	CRPointBits *pb = &(sb->point);	if (g->current.inBeginEnd)	{		crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glPointSize called in begin/end");		return;	}	FLUSH();	if (size <= 0.0f) 	{		crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glPointSize called with size <= 0.0: %f", size);		return;	}			p->pointSize = size;	DIRTY(pb->size, g->neg_bitid);	DIRTY(pb->dirty, g->neg_bitid);}

voidgen6_draw_vf(struct ilo_render *r,             const struct ilo_state_vector *vec,             struct ilo_render_draw_session *session){   if (ilo_dev_gen(r->dev) >= ILO_GEN(7.5)) {      /* 3DSTATE_INDEX_BUFFER */      if (DIRTY(IB) || r->batch_bo_changed) {         gen6_3DSTATE_INDEX_BUFFER(r->builder,               &vec->ib, false);      }      /* 3DSTATE_VF */      if (session->primitive_restart_changed) {         gen75_3DSTATE_VF(r->builder, vec->draw->primitive_restart,               vec->draw->restart_index);      }   }   else {      /* 3DSTATE_INDEX_BUFFER */      if (DIRTY(IB) || session->primitive_restart_changed ||          r->batch_bo_changed) {         gen6_3DSTATE_INDEX_BUFFER(r->builder,               &vec->ib, vec->draw->primitive_restart);      }   }   /* 3DSTATE_VERTEX_BUFFERS */   if (DIRTY(VB) || DIRTY(VE) || r->batch_bo_changed)      gen6_3DSTATE_VERTEX_BUFFERS(r->builder, vec->ve, &vec->vb);   /* 3DSTATE_VERTEX_ELEMENTS */   if (DIRTY(VE))      gen6_3DSTATE_VERTEX_ELEMENTS(r->builder, vec->ve);}

void STATE_APIENTRY crStateFrontFace (PCRStateTracker pState, GLenum mode) {    CRContext *g = GetCurrentContext(pState);    CRPolygonState *p = &(g->polygon);        CRStateBits *sb = GetCurrentBits(pState);    CRPolygonBits *pb = &(sb->polygon);    if (g->current.inBeginEnd)     {        crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION,                "glFrontFace called in begin/end");        return;    }    FLUSH();    if (mode != GL_CW && mode != GL_CCW)    {        crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM,                "glFrontFace called with bogus mode: 0x%x", mode);        return;    }    p->frontFace = mode;    DIRTY(pb->mode, g->neg_bitid);    DIRTY(pb->dirty, g->neg_bitid);}

voidgen6_draw_clip(struct ilo_render *r,               const struct ilo_state_vector *vec,               struct ilo_render_draw_session *session){   /* 3DSTATE_CLIP */   if (DIRTY(RASTERIZER) || DIRTY(FS) || DIRTY(VIEWPORT) || DIRTY(FB)) {      bool enable_guardband = true;      unsigned i;      /*       * We do not do 2D clipping yet.  Guard band test should only be enabled       * when the viewport is larger than the framebuffer.       */      for (i = 0; i < vec->viewport.count; i++) {         const struct ilo_viewport_cso *vp = &vec->viewport.cso[i];         if (vp->min_x > 0.0f || vp->max_x < vec->fb.state.width ||             vp->min_y > 0.0f || vp->max_y < vec->fb.state.height) {            enable_guardband = false;            break;         }      }      gen6_3DSTATE_CLIP(r->builder, vec->rasterizer,            vec->fs, enable_guardband, 1);   }}

void STATE_APIENTRY crStateClearAccum (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {    CRContext *g = GetCurrentContext();    CRBufferState *b = &(g->buffer);    CRStateBits *sp = GetCurrentBits();    CRBufferBits *bb = &(sp->buffer);    if (g->current.inBeginEnd)    {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glClearAccum called in begin/end");        return;    }        FLUSH();    if (red < -1.0f) red = 0.0f;    if (red > 1.0f) red = 1.0f;    if (green < -1.0f) green = 0.0f;    if (green > 1.0f) green = 1.0f;    if (blue < -1.0f) blue = 0.0f;    if (blue > 1.0f) blue = 1.0f;    if (alpha < -1.0f) alpha = 0.0f;    if (alpha > 1.0f) alpha = 1.0f;    b->accumClearValue.r = red;    b->accumClearValue.g = green;    b->accumClearValue.b = blue;    b->accumClearValue.a = alpha;    DIRTY(bb->dirty, g->neg_bitid);    DIRTY(bb->clearAccum, g->neg_bitid);}

static voidgen6_draw_wm(struct ilo_render *r,             const struct ilo_state_vector *vec,             struct ilo_render_draw_session *session){   /* 3DSTATE_CONSTANT_PS */   if (session->pcb_fs_changed) {      gen6_3DSTATE_CONSTANT_PS(r->builder,            &r->state.wm.PUSH_CONSTANT_BUFFER,            &r->state.wm.PUSH_CONSTANT_BUFFER_size,            1);   }   /* 3DSTATE_WM */   if (DIRTY(FS) || DIRTY(BLEND) || DIRTY(DSA) ||       DIRTY(RASTERIZER) || r->instruction_bo_changed) {      const bool dual_blend = vec->blend->dual_blend;      const bool cc_may_kill = (vec->dsa->dw_alpha ||                                vec->blend->alpha_to_coverage);      if (ilo_dev_gen(r->dev) == ILO_GEN(6) && r->hw_ctx_changed)         gen6_wa_pre_3dstate_wm_max_threads(r);      gen6_3DSTATE_WM(r->builder, vec->fs,            vec->rasterizer, dual_blend, cc_may_kill);   }}

static voidgen6_draw_wm_multisample(struct ilo_render *r,                         const struct ilo_state_vector *vec,                         struct ilo_render_draw_session *session){   /* 3DSTATE_MULTISAMPLE and 3DSTATE_SAMPLE_MASK */   if (DIRTY(SAMPLE_MASK) || DIRTY(FB)) {      const uint32_t *packed_sample_pos;      packed_sample_pos = (vec->fb.num_samples > 1) ?         &r->packed_sample_position_4x : &r->packed_sample_position_1x;      if (ilo_dev_gen(r->dev) == ILO_GEN(6)) {         gen6_wa_pre_non_pipelined(r);         gen6_wa_pre_3dstate_multisample(r);      }      gen6_3DSTATE_MULTISAMPLE(r->builder,            vec->fb.num_samples, packed_sample_pos,            vec->rasterizer->state.half_pixel_center);      gen6_3DSTATE_SAMPLE_MASK(r->builder,            (vec->fb.num_samples > 1) ? vec->sample_mask : 0x1);   }}

voidgen6_draw_wm_raster(struct ilo_render *r,                    const struct ilo_state_vector *vec,                    struct ilo_render_draw_session *session){   /* 3DSTATE_POLY_STIPPLE_PATTERN and 3DSTATE_POLY_STIPPLE_OFFSET */   if ((DIRTY(RASTERIZER) || DIRTY(POLY_STIPPLE)) &&       vec->rasterizer->state.poly_stipple_enable) {      if (ilo_dev_gen(r->dev) == ILO_GEN(6))         gen6_wa_pre_non_pipelined(r);      gen6_3DSTATE_POLY_STIPPLE_PATTERN(r->builder,            &vec->poly_stipple);      gen6_3DSTATE_POLY_STIPPLE_OFFSET(r->builder, 0, 0);   }   /* 3DSTATE_LINE_STIPPLE */   if (DIRTY(RASTERIZER) && vec->rasterizer->state.line_stipple_enable) {      if (ilo_dev_gen(r->dev) == ILO_GEN(6))         gen6_wa_pre_non_pipelined(r);      gen6_3DSTATE_LINE_STIPPLE(r->builder,            vec->rasterizer->state.line_stipple_pattern,            vec->rasterizer->state.line_stipple_factor + 1);   }   /* 3DSTATE_AA_LINE_PARAMETERS */   if (DIRTY(RASTERIZER) && vec->rasterizer->state.line_smooth) {      if (ilo_dev_gen(r->dev) == ILO_GEN(6))         gen6_wa_pre_non_pipelined(r);      gen6_3DSTATE_AA_LINE_PARAMETERS(r->builder);   }}

void STATE_APIENTRY crStateCullFace(GLenum mode) {	CRContext *g = GetCurrentContext();	CRPolygonState *p = &(g->polygon);        CRStateBits *sb = GetCurrentBits();	CRPolygonBits *pb = &(sb->polygon);	if (g->current.inBeginEnd) 	{		crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,				"glCullFace called in begin/end");		return;	}	FLUSH();	if (mode != GL_FRONT && mode != GL_BACK && mode != GL_FRONT_AND_BACK)	{		crStateError(__LINE__, __FILE__, GL_INVALID_ENUM,				"glCullFace called with bogus mode: 0x%x", mode);		return;	}	p->cullFaceMode = mode;	DIRTY(pb->mode, g->neg_bitid);	DIRTY(pb->dirty, g->neg_bitid);}

void STATE_APIENTRY crStatePolygonStipple (const GLubyte *p) {	CRContext *g = GetCurrentContext();	CRPolygonState *poly = &(g->polygon);        CRStateBits *sb = GetCurrentBits();	CRPolygonBits *pb = &(sb->polygon);	if (g->current.inBeginEnd) 	{		crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,				"glPolygonStipple called in begin/end");		return;	}	FLUSH();	if (!p)	{		crStateError(__LINE__, __FILE__, GL_NO_ERROR,				"Void pointer passed to PolygonStipple");		return;	}	crMemcpy((char*)poly->stipple, (char*)p, 128);	DIRTY(pb->dirty, g->neg_bitid);	DIRTY(pb->stipple, g->neg_bitid);}

static voidgen6_emit_draw_surface_view(struct ilo_render *r,                            const struct ilo_state_vector *vec,                            int shader_type,                            struct ilo_render_draw_session *session){   const struct ilo_view_state *view = &vec->view[shader_type];   const struct ilo_shader_state *sh;   uint32_t *surface_state;   int base, count, i;   ILO_DEV_ASSERT(r->dev, 6, 7.5);   switch (shader_type) {   case PIPE_SHADER_VERTEX:      if (!DIRTY(VS) && !DIRTY(VIEW_VS))         return;      if (!vec->vs)         return;      sh = vec->vs;      surface_state = r->state.vs.SURFACE_STATE;      session->binding_table_vs_changed = true;      break;   case PIPE_SHADER_FRAGMENT:      if (!DIRTY(FS) && !DIRTY(VIEW_FS))         return;      if (!vec->fs)         return;      sh = vec->fs;      surface_state = r->state.wm.SURFACE_STATE;      session->binding_table_fs_changed = true;      break;   default:      return;      break;   }   base = ilo_shader_get_kernel_param(sh, ILO_KERNEL_SURFACE_TEX_BASE);   count = ilo_shader_get_kernel_param(sh, ILO_KERNEL_SURFACE_TEX_COUNT);   /* SURFACE_STATEs for sampler views */   surface_state += base;   for (i = 0; i < count; i++) {      if (i < view->count && view->states[i]) {         const struct ilo_view_cso *cso =            (const struct ilo_view_cso *) view->states[i];         surface_state[i] =            gen6_SURFACE_STATE(r->builder, &cso->surface, false);      } else {         surface_state[i] = 0;      }   }}

static voidgen6_emit_draw_surface_const(struct ilo_render *r,                             const struct ilo_state_vector *vec,                             int shader_type,                             struct ilo_render_draw_session *session){   const struct ilo_cbuf_state *cbuf = &vec->cbuf[shader_type];   const struct ilo_shader_state *sh;   uint32_t *surface_state;   int base, count, i;   ILO_DEV_ASSERT(r->dev, 6, 7.5);   switch (shader_type) {   case PIPE_SHADER_VERTEX:      if (!DIRTY(VS) && !DIRTY(CBUF))         return;      if (!vec->vs)         return;      sh = vec->vs;      surface_state = r->state.vs.SURFACE_STATE;      session->binding_table_vs_changed = true;      break;   case PIPE_SHADER_FRAGMENT:      if (!DIRTY(FS) && !DIRTY(CBUF))         return;      if (!vec->fs)         return;      sh = vec->fs;      surface_state = r->state.wm.SURFACE_STATE;      session->binding_table_fs_changed = true;      break;   default:      return;      break;   }   base = ilo_shader_get_kernel_param(sh, ILO_KERNEL_SURFACE_CONST_BASE);   count = ilo_shader_get_kernel_param(sh, ILO_KERNEL_SURFACE_CONST_COUNT);   /* SURFACE_STATEs for constant buffers */   surface_state += base;   for (i = 0; i < count; i++) {      const struct ilo_cbuf_cso *cso = &cbuf->cso[i];      if (cso->resource) {         surface_state[i] = gen6_SURFACE_STATE(r->builder,               &cso->surface, false);      } else {         surface_state[i] = 0;      }   }}

void STATE_APIENTRYcrStateBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data){    CRContext *g = GetCurrentContext();    CRBufferObjectState *b = &g->bufferobject;    CRBufferObject *obj;    CRStateBits *sb = GetCurrentBits();    CRBufferObjectBits *bb = &sb->bufferobject;    FLUSH();    if (g->current.inBeginEnd) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,                                 "glBufferSubDataARB called in begin/end");        return;    }    obj = crStateGetBoundBufferObject(target, b);    if (!obj)    {        crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glBufferSubDataARB(target)");        return;    }    if (obj->id == 0) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,                                 "glBufferSubDataARB");        return;    }    if (obj->pointer) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,                                 "glBufferSubDataARB(buffer is mapped)");        return;    }    if (size < 0 || offset < 0 || (unsigned int)offset + size > obj->size) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,                                 "glBufferSubDataARB(bad offset and/or size)");        return;    }    if (b->retainBufferData && obj->data) {        crMemcpy((char *) obj->data + offset, data, size);    }    DIRTY(bb->dirty, g->neg_bitid);    DIRTY(obj->dirty, g->neg_bitid);    /* grow dirty region */    if (offset + size > obj->dirtyStart + obj->dirtyLength)        obj->dirtyLength = offset + size;    if (offset < obj->dirtyStart)        obj->dirtyStart = offset;}

static voidgen6_draw_sf(struct ilo_render *r,             const struct ilo_state_vector *vec,             struct ilo_render_draw_session *session){   /* 3DSTATE_SF */   if (DIRTY(RASTERIZER) || DIRTY(FS) || DIRTY(FB)) {      gen6_3DSTATE_SF(r->builder, vec->rasterizer, vec->fs,            vec->fb.num_samples);   }}

static voidgen6_emit_draw_surface_so(struct ilo_render *r,                          const struct ilo_state_vector *vec,                          struct ilo_render_draw_session *session){   const struct ilo_shader_state *vs = vec->vs;   const struct ilo_shader_state *gs = vec->gs;   const struct ilo_so_state *so = &vec->so;   const struct pipe_stream_output_info *so_info;   uint32_t *surface_state;   int base, count, i;   ILO_DEV_ASSERT(r->dev, 6, 6);   if (!DIRTY(VS) && !DIRTY(GS) && !DIRTY(SO))      return;   if (gs) {      so_info = ilo_shader_get_kernel_so_info(gs);      base = ilo_shader_get_kernel_param(gs,            ILO_KERNEL_GS_GEN6_SURFACE_SO_BASE);      count = ilo_shader_get_kernel_param(gs,            ILO_KERNEL_GS_GEN6_SURFACE_SO_COUNT);   } else if (vs) {      so_info = ilo_shader_get_kernel_so_info(vs);      base = 0;      count = ilo_shader_get_kernel_param(vs,            ILO_KERNEL_VS_GEN6_SO_SURFACE_COUNT);   } else {      return;   }   session->binding_table_gs_changed = true;   /* SURFACE_STATEs for stream output targets */   surface_state = &r->state.gs.SURFACE_STATE[base];   for (i = 0; i < count; i++) {      if (so_info && i < so_info->num_outputs &&          so_info->output[i].output_buffer < so->count &&          so->states[so_info->output[i].output_buffer]) {         const struct pipe_stream_output_target *so_target =            so->states[so_info->output[i].output_buffer];         surface_state[i] = gen6_so_SURFACE_STATE(r->builder,               so_target, so_info, i);      } else {         surface_state[i] = 0;      }   }}

static voidgen8_draw_wm_multisample(struct ilo_render *r,                         const struct ilo_state_vector *vec,                         struct ilo_render_draw_session *session){   /* 3DSTATE_MULTISAMPLE and 3DSTATE_SAMPLE_MASK */   if (DIRTY(SAMPLE_MASK) || DIRTY(FB) || DIRTY(RASTERIZER)) {      gen8_3DSTATE_MULTISAMPLE(r->builder, vec->fb.num_samples,            vec->rasterizer->state.half_pixel_center);      gen7_3DSTATE_SAMPLE_MASK(r->builder,            (vec->fb.num_samples > 1) ? vec->sample_mask : 0x1,            vec->fb.num_samples);   }}

voidgen6_draw_vs(struct ilo_render *r,             const struct ilo_state_vector *vec,             struct ilo_render_draw_session *session){   const bool emit_3dstate_vs = (DIRTY(VS) || r->instruction_bo_changed);   const bool emit_3dstate_constant_vs = session->pcb_vs_changed;   /*    * the classic i965 does this in upload_vs_state(), citing a spec that I    * cannot find    */   if (emit_3dstate_vs && ilo_dev_gen(r->dev) == ILO_GEN(6))      gen6_wa_pre_non_pipelined(r);   /* 3DSTATE_CONSTANT_VS */   if (emit_3dstate_constant_vs) {      gen6_3DSTATE_CONSTANT_VS(r->builder,            &r->state.vs.PUSH_CONSTANT_BUFFER,            &r->state.vs.PUSH_CONSTANT_BUFFER_size,            1);   }   /* 3DSTATE_VS */   if (emit_3dstate_vs)      gen6_3DSTATE_VS(r->builder, vec->vs);   if (emit_3dstate_constant_vs && ilo_dev_gen(r->dev) == ILO_GEN(6))      gen6_wa_post_3dstate_constant_vs(r);}

static voidgen6_emit_draw_dynamic_scissors(struct ilo_render *r,                                const struct ilo_state_vector *vec,                                struct ilo_render_draw_session *session){   ILO_DEV_ASSERT(r->dev, 6, 7.5);   /* SCISSOR_RECT */   if (DIRTY(SCISSOR) || DIRTY(VIEWPORT)) {      /* there should be as many scissors as there are viewports */      r->state.SCISSOR_RECT = gen6_SCISSOR_RECT(r->builder,            &vec->scissor, vec->viewport.count);      session->scissor_changed = true;   }}

// **************************************************************************// **************************************************************************// output page table entryvoid outPTE(char* s, int pte){	int pte1, pte2;	char flags[10];	// read pt	pte1 = memory[pte];	pte2 = memory[pte+1];	// look at appropriate flags	strcpy(flags, "-----");	if (DEFINED(pte1)) flags[0] = 'F';	if (DIRTY(pte1)) flags[1] = 'D';	if (REFERENCED(pte1)) flags[2] = 'R';	if (PINNED(pte1)) flags[3] = 'P';	if (PAGED(pte2)) flags[4] = 'S';	// output pte line	if(DEFINED(pte1) || DEFINED(pte2))		printf("/n%s x%04x = %04x %04x  %s", s, pte, pte1, pte2, flags);	if (DEFINED(pte1) || DEFINED(pte2)) printf(" Frame=%d", FRAME(pte1));	if (DEFINED(pte2)) printf(" Page=%d", SWAPPAGE(pte2));	return;} // end outPTE

void swapOutFrame(int entry1Index){    // clear the definition bit in entry 1 probably just set entry 1 to 0    int entry1, entry2;    entry1 = memory[entry1Index];    entry2 = memory[entry1Index + 1];    // if dirty bit is not set and swap exists we are done    if (DIRTY(entry1) && PAGED(entry2)) {        DEBUG_STATEMENT(DEBUG_MMU,"/nDirty copy of swap write to old page");        // if swap exits swap access page with old write        accessPage(SWAPPAGE(entry2), FRAME(entry1), PAGE_OLD_WRITE);    } else if (!PAGED(entry2)) {        DEBUG_STATEMENT(DEBUG_MMU,"/nNo copy in swap write to new swap");        // if swap doesn't exist then we need to write out to an new write        memory[entry1Index + 1] = entry2 = SET_PAGED(nextPage);        accessPage(nextPage, FRAME(entry1), PAGE_NEW_WRITE);    }    if (DEBUG_MMU) { outPTE("/nSwapped Entry - (Pre-clear) ", entry1Index); }    memory[entry1Index] = 0;    if (DEBUG_MMU) { outPTE("Swapped Entry - ", entry1Index); }    return;}

void STATE_APIENTRY crStatePopClientAttrib( void ){	CRContext *g = GetCurrentContext();	CRClientState *c = &(g->client);	CRStateBits *sb = GetCurrentBits();	CRClientBits *cb = &(sb->client);	CRbitvalue mask;	if (g->current.inBeginEnd) {		crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,								 "glPopClientAttrib called in Begin/End");		return;	}	if (c->attribStackDepth == 0) {		crStateError(__LINE__, __FILE__, GL_STACK_UNDERFLOW,								 "glPopClientAttrib called with an empty stack!" );		return;	}	FLUSH();	mask = c->pushMaskStack[--c->attribStackDepth];	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {		if (c->pixelStoreStackDepth == 0) {			crError("bug in glPopClientAttrib (pixel store) ");			return;		}		c->pixelStoreStackDepth--;		c->pack = c->pixelPackStoreStack[c->pixelStoreStackDepth];		c->unpack = c->pixelUnpackStoreStack[c->pixelStoreStackDepth];		DIRTY(cb->pack, g->neg_bitid);	}	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {		if (c->vertexArrayStackDepth == 0) {			crError("bug in glPopClientAttrib (vertex array) ");			return;		}		c->vertexArrayStackDepth--;		c->array = c->vertexArrayStack[c->vertexArrayStackDepth];		DIRTY(cb->clientPointer, g->neg_bitid);	}	DIRTY(cb->dirty, g->neg_bitid);}

GLboolean STATE_APIENTRYcrStateUnmapBufferARB(GLenum target){    CRContext *g = GetCurrentContext();    CRBufferObjectState *b = &g->bufferobject;    CRBufferObject *obj;    CRStateBits *sb = GetCurrentBits();    CRBufferObjectBits *bb = &sb->bufferobject;    FLUSH();    if (g->current.inBeginEnd) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,                                 "glUnmapBufferARB called in begin/end");        return GL_FALSE;    }    obj = crStateGetBoundBufferObject(target, b);    if (!obj)    {        crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glUnmapBufferARB(target)");        return GL_FALSE;    }    if (obj->id == 0) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glUnmapBufferARB");        return GL_FALSE;    }    if (!obj->pointer) {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glUnmapBufferARB");        return GL_FALSE;    }    obj->pointer = NULL;    if (obj->access != GL_READ_ONLY_ARB) {        /* the data was most likely modified */        DIRTY(bb->dirty, g->neg_bitid);        DIRTY(obj->dirty, g->neg_bitid);        obj->dirtyStart = 0;        obj->dirtyLength = obj->size;    }    return GL_TRUE;}

void STATE_APIENTRY crStateClearIndex (GLfloat c) {    CRContext *g = GetCurrentContext();    CRBufferState *b = &(g->buffer);    CRStateBits *sp = GetCurrentBits();    CRBufferBits *bb = &(sp->buffer);    if (g->current.inBeginEnd)    {        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glClearIndex called in begin/end");        return;    }    b->indexClearValue = c;    DIRTY(bb->dirty, g->neg_bitid);    DIRTY(bb->clearIndex, g->neg_bitid);}

static voidgen6_emit_draw_dynamic_cc(struct ilo_render *r,                          const struct ilo_state_vector *vec,                          struct ilo_render_draw_session *session){   ILO_DEV_ASSERT(r->dev, 6, 7.5);   /* BLEND_STATE */   if (DIRTY(BLEND) || DIRTY(FB) || DIRTY(DSA)) {      r->state.BLEND_STATE = gen6_BLEND_STATE(r->builder,            vec->blend, &vec->fb, vec->dsa);      session->blend_changed = true;   }   /* COLOR_CALC_STATE */   if (DIRTY(DSA) || DIRTY(STENCIL_REF) || DIRTY(BLEND_COLOR)) {      r->state.COLOR_CALC_STATE =         gen6_COLOR_CALC_STATE(r->builder, &vec->stencil_ref,               vec->dsa->alpha_ref, &vec->blend_color);      session->cc_changed = true;   }   /* DEPTH_STENCIL_STATE */   if (DIRTY(DSA)) {      r->state.DEPTH_STENCIL_STATE =         gen6_DEPTH_STENCIL_STATE(r->builder, vec->dsa);      session->dsa_changed = true;   }}