struct r700_vertex_program* r700TranslateVertexShader(struct gl_context *ctx,
struct gl_vertex_program *mesa_vp)
{
context_t *context = R700_CONTEXT(ctx);
R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
struct r700_vertex_program *vp;
unsigned int i;
vp = calloc(1, sizeof(*vp));
vp->mesa_program = _mesa_clone_vertex_program(ctx, mesa_vp);
vp->constbo0 = NULL;
if (mesa_vp->IsPositionInvariant)
{
_mesa_insert_mvp_code(ctx, vp->mesa_program);
}
for(i=0; i<context->nNumActiveAos; i++)
{
vp->aos_desc[i].size = context->stream_desc[i].size;
vp->aos_desc[i].stride = context->stream_desc[i].stride;
vp->aos_desc[i].type = context->stream_desc[i].type;
vp->aos_desc[i].format = context->stream_desc[i].format;
}
if (context->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV770)
{
vp->r700AsmCode.bR6xx = 1;
}
//Init_Program
Init_r700_AssemblerBase(SPT_VP, &(vp->r700AsmCode), &(vp->r700Shader) );
if(GL_TRUE == r700->bShaderUseMemConstant)
{
vp->r700AsmCode.bUseMemConstant = GL_TRUE;
}
else
{
vp->r700AsmCode.bUseMemConstant = GL_FALSE;
}
vp->r700AsmCode.unAsic = 7;
Map_Vertex_Program(ctx, vp, vp->mesa_program );
if(GL_FALSE == Find_Instruction_Dependencies_vp(vp, vp->mesa_program))
{
return NULL;
}
InitShaderProgram(&(vp->r700AsmCode));
for(i=0; i < MAX_SAMPLERS; i++)
{
vp->r700AsmCode.SamplerUnits[i] = vp->mesa_program->Base.SamplerUnits[i];
}
vp->r700AsmCode.unCurNumILInsts = vp->mesa_program->Base.NumInstructions;
if(GL_FALSE == AssembleInstr(0,
0,
vp->mesa_program->Base.NumInstructions,
&(vp->mesa_program->Base.Instructions[0]),
&(vp->r700AsmCode)) )
{
return NULL;
}
if(GL_FALSE == Process_Vertex_Exports(&(vp->r700AsmCode), vp->mesa_program->Base.OutputsWritten) )
{
return NULL;
}
if( GL_FALSE == RelocProgram(&(vp->r700AsmCode), &(vp->mesa_program->Base)) )
{
return GL_FALSE;
}
vp->r700Shader.nRegs = (vp->r700AsmCode.number_used_registers == 0) ? 0
: (vp->r700AsmCode.number_used_registers - 1);
vp->r700Shader.nParamExports = vp->r700AsmCode.number_of_exports;
vp->translated = GL_TRUE;
return vp;
}
/**
* Shader linker. Currently:
*
* 1. The last attached vertex shader and fragment shader are linked.
* 2. Varying vars in the two shaders are combined so their locations
* agree between the vertex and fragment stages. They're treated as
* vertex program output attribs and as fragment program input attribs.
* 3. The vertex and fragment programs are cloned and modified to update
* src/dst register references so they use the new, linked varying
* storage locations.
*/
void
_slang_link(GLcontext *ctx,
GLhandleARB programObj,
struct gl_shader_program *shProg)
{
const struct gl_vertex_program *vertProg = NULL;
const struct gl_fragment_program *fragProg = NULL;
GLboolean vertNotify = GL_TRUE, fragNotify = GL_TRUE;
GLuint numSamplers = 0;
GLuint i;
_mesa_clear_shader_program_data(ctx, shProg);
/* Initialize LinkStatus to "success". Will be cleared if error. */
shProg->LinkStatus = GL_TRUE;
/* check that all programs compiled successfully */
for (i = 0; i < shProg->NumShaders; i++) {
if (!shProg->Shaders[i]->CompileStatus) {
link_error(shProg, "linking with uncompiled shader\n");
return;
}
}
shProg->Uniforms = _mesa_new_uniform_list();
shProg->Varying = _mesa_new_parameter_list();
/*
* Find the vertex and fragment shaders which define main()
*/
{
struct gl_shader *vertShader, *fragShader;
vertShader = get_main_shader(ctx, shProg, GL_VERTEX_SHADER);
fragShader = get_main_shader(ctx, shProg, GL_FRAGMENT_SHADER);
if (vertShader)
vertProg = vertex_program(vertShader->Program);
if (fragShader)
fragProg = fragment_program(fragShader->Program);
if (!shProg->LinkStatus)
return;
}
#if FEATURE_es2_glsl
/* must have both a vertex and fragment program for ES2 */
if (!vertProg) {
link_error(shProg, "missing vertex shader\n");
return;
}
if (!fragProg) {
link_error(shProg, "missing fragment shader\n");
return;
}
#endif
/*
* Make copies of the vertex/fragment programs now since we'll be
* changing src/dst registers after merging the uniforms and varying vars.
*/
_mesa_reference_vertprog(ctx, &shProg->VertexProgram, NULL);
if (vertProg) {
struct gl_vertex_program *linked_vprog =
_mesa_clone_vertex_program(ctx, vertProg);
shProg->VertexProgram = linked_vprog; /* refcount OK */
/* vertex program ID not significant; just set Id for debugging purposes */
shProg->VertexProgram->Base.Id = shProg->Name;
ASSERT(shProg->VertexProgram->Base.RefCount == 1);
}
_mesa_reference_fragprog(ctx, &shProg->FragmentProgram, NULL);
if (fragProg) {
struct gl_fragment_program *linked_fprog =
_mesa_clone_fragment_program(ctx, fragProg);
shProg->FragmentProgram = linked_fprog; /* refcount OK */
/* vertex program ID not significant; just set Id for debugging purposes */
shProg->FragmentProgram->Base.Id = shProg->Name;
ASSERT(shProg->FragmentProgram->Base.RefCount == 1);
}
/* link varying vars */
if (shProg->VertexProgram) {
if (!link_varying_vars(ctx, shProg, &shProg->VertexProgram->Base))
return;
}
if (shProg->FragmentProgram) {
if (!link_varying_vars(ctx, shProg, &shProg->FragmentProgram->Base))
return;
}
/* link uniform vars */
if (shProg->VertexProgram) {
if (!link_uniform_vars(ctx, shProg, &shProg->VertexProgram->Base,
&numSamplers)) {
return;
}
}
if (shProg->FragmentProgram) {
if (!link_uniform_vars(ctx, shProg, &shProg->FragmentProgram->Base,
&numSamplers)) {
return;
}
}
/*_mesa_print_uniforms(shProg->Uniforms);*/
if (shProg->VertexProgram) {
if (!_slang_resolve_attributes(shProg, &vertProg->Base,
&shProg->VertexProgram->Base)) {
return;
}
}
if (shProg->VertexProgram) {
_slang_update_inputs_outputs(&shProg->VertexProgram->Base);
_slang_count_temporaries(&shProg->VertexProgram->Base);
if (!(shProg->VertexProgram->Base.OutputsWritten
& BITFIELD64_BIT(VERT_RESULT_HPOS))) {
/* the vertex program did not compute a vertex position */
link_error(shProg,
"gl_Position was not written by vertex shader\n");
return;
}
}
if (shProg->FragmentProgram) {
_slang_count_temporaries(&shProg->FragmentProgram->Base);
_slang_update_inputs_outputs(&shProg->FragmentProgram->Base);
}
/* Check that all the varying vars needed by the fragment shader are
* actually produced by the vertex shader.
*/
if (shProg->FragmentProgram) {
const GLbitfield varyingRead
= shProg->FragmentProgram->Base.InputsRead >> FRAG_ATTRIB_VAR0;
const GLbitfield64 varyingWritten = shProg->VertexProgram ?
shProg->VertexProgram->Base.OutputsWritten >> VERT_RESULT_VAR0 : 0x0;
if ((varyingRead & varyingWritten) != varyingRead) {
link_error(shProg,
"Fragment program using varying vars not written by vertex shader\n");
return;
}
}
/* check that gl_FragColor and gl_FragData are not both written to */
if (shProg->FragmentProgram) {
const GLbitfield64 outputsWritten =
shProg->FragmentProgram->Base.OutputsWritten;
if ((outputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) &&
(outputsWritten >= BITFIELD64_BIT(FRAG_RESULT_DATA0))) {
link_error(shProg, "Fragment program cannot write both gl_FragColor"
" and gl_FragData[].\n");
return;
}
}
if (fragProg && shProg->FragmentProgram) {
/* Compute initial program's TexturesUsed info */
_mesa_update_shader_textures_used(&shProg->FragmentProgram->Base);
/* notify driver that a new fragment program has been compiled/linked */
vertNotify = ctx->Driver.ProgramStringNotify(ctx, GL_FRAGMENT_PROGRAM_ARB,
&shProg->FragmentProgram->Base);
if (ctx->Shader.Flags & GLSL_DUMP) {
printf("Mesa pre-link fragment program:\n");
_mesa_print_program(&fragProg->Base);
_mesa_print_program_parameters(ctx, &fragProg->Base);
printf("Mesa post-link fragment program:\n");
_mesa_print_program(&shProg->FragmentProgram->Base);
_mesa_print_program_parameters(ctx, &shProg->FragmentProgram->Base);
}
}
if (vertProg && shProg->VertexProgram) {
/* Compute initial program's TexturesUsed info */
_mesa_update_shader_textures_used(&shProg->VertexProgram->Base);
/* notify driver that a new vertex program has been compiled/linked */
fragNotify = ctx->Driver.ProgramStringNotify(ctx, GL_VERTEX_PROGRAM_ARB,
&shProg->VertexProgram->Base);
if (ctx->Shader.Flags & GLSL_DUMP) {
printf("Mesa pre-link vertex program:\n");
_mesa_print_program(&vertProg->Base);
_mesa_print_program_parameters(ctx, &vertProg->Base);
printf("Mesa post-link vertex program:\n");
_mesa_print_program(&shProg->VertexProgram->Base);
_mesa_print_program_parameters(ctx, &shProg->VertexProgram->Base);
}
}
/* Debug: */
if (0) {
if (shProg->VertexProgram)
_mesa_postprocess_program(ctx, &shProg->VertexProgram->Base);
if (shProg->FragmentProgram)
_mesa_postprocess_program(ctx, &shProg->FragmentProgram->Base);
}
if (ctx->Shader.Flags & GLSL_DUMP) {
printf("Varying vars:\n");
_mesa_print_parameter_list(shProg->Varying);
if (shProg->InfoLog) {
printf("Info Log: %s\n", shProg->InfoLog);
}
}
if (!vertNotify || !fragNotify) {
/* driver rejected one/both of the vertex/fragment programs */
if (!shProg->InfoLog) {
link_error(shProg,
"Vertex and/or fragment program rejected by driver\n");
}
}
else {
shProg->LinkStatus = (shProg->VertexProgram || shProg->FragmentProgram);
}
}
