-/* $Id: nvprogram.c,v 1.2 2003/02/10 20:31:11 alanh Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 5.1
+ * Version: 6.5.2
*
- * Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
/**
* \file nvprogram.c
- * \brief NVIDIA vertex/fragment program state management functions.
+ * NVIDIA vertex/fragment program state management functions.
* \author Brian Paul
*/
-
-#include "glheader.h"
-#include "context.h"
-#include "hash.h"
-#include "imports.h"
-#include "macros.h"
-#include "mtypes.h"
-#include "nvfragparse.h"
-#include "nvfragprog.h"
-#include "nvvertexec.h"
-#include "nvvertparse.h"
-#include "nvvertprog.h"
-#include "nvprogram.h"
-
-
-
-/**
- * Set the vertex/fragment program error state (position and error string).
- * This is generally called from within the parsers.
- */
-void
-_mesa_set_program_error(GLcontext *ctx, GLint pos, const char *string)
-{
- ctx->Program.ErrorPos = pos;
- _mesa_free((void *) ctx->Program.ErrorString);
- if (!string)
- string = "";
- ctx->Program.ErrorString = _mesa_strdup(string);
-}
-
-
-/**
- * Delete a program and remove it from the hash table, ignoring the
- * reference count.
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_delete_program(GLcontext *ctx, GLuint id)
-{
- struct program *prog = (struct program *)
- _mesa_HashLookup(ctx->Shared->Programs, id);
-
- if (prog) {
- if (prog->String)
- FREE(prog->String);
- if (prog->Target == GL_VERTEX_PROGRAM_NV ||
- prog->Target == GL_VERTEX_STATE_PROGRAM_NV) {
- struct vertex_program *vprog = (struct vertex_program *) prog;
- if (vprog->Instructions)
- FREE(vprog->Instructions);
- }
- else if (prog->Target == GL_FRAGMENT_PROGRAM_NV) {
- struct fragment_program *fprog = (struct fragment_program *) prog;
- if (fprog->Instructions)
- FREE(fprog->Instructions);
- }
- _mesa_HashRemove(ctx->Shared->Programs, id);
- FREE(prog);
- }
-}
-
-
-/**
- * Bind a program (make it current)
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_BindProgramNV(GLenum target, GLuint id)
-{
- struct program *prog;
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END(ctx);
-
- if (target == GL_VERTEX_PROGRAM_NV) {
- if (ctx->VertexProgram.Current &&
- ctx->VertexProgram.Current->Base.Id == id)
- return;
- /* decrement refcount on previously bound vertex program */
- if (ctx->VertexProgram.Current) {
- ctx->VertexProgram.Current->Base.RefCount--;
- /* and delete if refcount goes below one */
- if (ctx->VertexProgram.Current->Base.RefCount <= 0)
- _mesa_delete_program(ctx, ctx->VertexProgram.Current->Base.Id);
- }
- }
- else if (target == GL_FRAGMENT_PROGRAM_NV) {
- if (ctx->FragmentProgram.Current &&
- ctx->FragmentProgram.Current->Base.Id == id)
- return;
- /* decrement refcount on previously bound fragment program */
- if (ctx->FragmentProgram.Current) {
- ctx->FragmentProgram.Current->Base.RefCount--;
- /* and delete if refcount goes below one */
- if (ctx->FragmentProgram.Current->Base.RefCount <= 0)
- _mesa_delete_program(ctx, ctx->FragmentProgram.Current->Base.Id);
- }
- }
- else {
- _mesa_error(ctx, GL_INVALID_ENUM, "glBindProgramNV");
- return;
- }
-
- /* NOTE: binding to a non-existant program is not an error.
- * That's supposed to be caught in glBegin.
- */
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
-
- if (!prog && id > 0){
- /* allocate new program */
- if (target == GL_VERTEX_PROGRAM_NV) {
- struct vertex_program *vprog = CALLOC_STRUCT(vertex_program);
- if (!vprog) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindProgramNV");
- return;
- }
- prog = &(vprog->Base);
- }
- else if (target == GL_FRAGMENT_PROGRAM_NV) {
- struct fragment_program *fprog = CALLOC_STRUCT(fragment_program);
- if (!fprog) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindProgramNV");
- return;
- }
- prog = &(fprog->Base);
- }
- else {
- _mesa_error(ctx, GL_INVALID_ENUM, "glBindProgramNV(target)");
- return;
- }
- prog->Id = id;
- prog->Target = target;
- prog->Resident = GL_TRUE;
- prog->RefCount = 1;
- _mesa_HashInsert(ctx->Shared->Programs, id, prog);
- }
-
- /* bind now */
- if (target == GL_VERTEX_PROGRAM_NV) {
- ctx->VertexProgram.Current = (struct vertex_program *) prog;
- }
- else if (target == GL_FRAGMENT_PROGRAM_NV) {
- ctx->FragmentProgram.Current = (struct fragment_program *) prog;
- }
-
- if (prog)
- prog->RefCount++;
-}
-
-
-/**
- * Delete a list of programs.
- * \note Not compiled into display lists.
- * \note Called from the GL API dispatcher.
+/*
+ * Regarding GL_NV_fragment_program:
+ *
+ * Portions of this software may use or implement intellectual
+ * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
+ * any and all warranties with respect to such intellectual property,
+ * including any use thereof or modifications thereto.
*/
-void
-_mesa_DeleteProgramsNV(GLsizei n, const GLuint *ids)
-{
- GLint i;
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (n < 0) {
- _mesa_error( ctx, GL_INVALID_VALUE, "glDeleteProgramsNV" );
- return;
- }
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/hash.h"
+#include "main/imports.h"
+#include "main/macros.h"
+#include "main/mtypes.h"
+#include "main/nvprogram.h"
+#include "program/arbprogparse.h"
+#include "program/nvfragparse.h"
+#include "program/program.h"
+#include "program/prog_instruction.h"
+#include "program/prog_parameter.h"
- for (i = 0; i < n; i++) {
- if (ids[i] != 0) {
- struct program *prog = (struct program *)
- _mesa_HashLookup(ctx->Shared->Programs, ids[i]);
- if (prog) {
- if (prog->Target == GL_VERTEX_PROGRAM_NV ||
- prog->Target == GL_VERTEX_STATE_PROGRAM_NV) {
- if (ctx->VertexProgram.Current &&
- ctx->VertexProgram.Current->Base.Id == ids[i]) {
- /* unbind this currently bound program */
- _mesa_BindProgramNV(prog->Target, 0);
- }
- }
- else if (prog->Target == GL_FRAGMENT_PROGRAM_NV) {
- if (ctx->FragmentProgram.Current &&
- ctx->FragmentProgram.Current->Base.Id == ids[i]) {
- /* unbind this currently bound program */
- _mesa_BindProgramNV(prog->Target, 0);
- }
- }
- else {
- _mesa_problem(ctx, "bad target in glDeleteProgramsNV");
- return;
- }
- prog->RefCount--;
- if (prog->RefCount <= 0) {
- _mesa_delete_program(ctx, ids[i]);
- }
- }
- }
- }
-}
/**
* Execute a vertex state program.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
{
- struct vertex_program *vprog;
+ struct gl_vertex_program *vprog;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
return;
}
- vprog = (struct vertex_program *)
- _mesa_HashLookup(ctx->Shared->Programs, id);
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+
+ vprog = gl_vertex_program(_mesa_lookup_program(ctx, id));
if (!vprog || vprog->Base.Target != GL_VERTEX_STATE_PROGRAM_NV) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glExecuteProgramNV");
return;
}
- _mesa_init_vp_registers(ctx);
- _mesa_init_tracked_matrices(ctx);
- COPY_4V(ctx->VertexProgram.Machine.Registers[VP_INPUT_REG_START], params);
- _mesa_exec_vertex_program(ctx, vprog);
-}
-
-
-/**
- * Generate a list of new program identifiers.
- * \note Not compiled into display lists.
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_GenProgramsNV(GLsizei n, GLuint *ids)
-{
- GLuint first;
- GLuint i;
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END(ctx);
-
- if (n < 0) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGenProgramsNV");
- return;
- }
-
- if (!ids)
- return;
-
- first = _mesa_HashFindFreeKeyBlock(ctx->Shared->Programs, n);
-
- for (i = 0; i < (GLuint) n; i++) {
- const int bytes = MAX2(sizeof(struct vertex_program),
- sizeof(struct fragment_program));
- struct program *prog = (struct program *) CALLOC(bytes);
- if (!prog) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenProgramsNV");
- return;
- }
- prog->RefCount = 1;
- prog->Id = first + i;
- _mesa_HashInsert(ctx->Shared->Programs, first + i, prog);
- }
-
- /* Return the program names */
- for (i = 0; i < (GLuint) n; i++) {
- ids[i] = first + i;
- }
+ _mesa_problem(ctx, "glExecuteProgramNV() not supported");
}
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-GLboolean _mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids,
- GLboolean *residences)
+GLboolean GLAPIENTRY
+_mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids,
+ GLboolean *residences)
{
- GLint i;
- GLboolean retVal = GL_TRUE;
+ GLint i, j;
+ GLboolean allResident = GL_TRUE;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
}
for (i = 0; i < n; i++) {
- struct program *prog;
-
+ const struct gl_program *prog;
if (ids[i] == 0) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV(id=0)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV");
return GL_FALSE;
}
-
- prog = (struct program *)
- _mesa_HashLookup(ctx->Shared->Programs, ids[i]);
+ prog = _mesa_lookup_program(ctx, ids[i]);
if (!prog) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV(id)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV");
return GL_FALSE;
}
-
- if (!prog->Resident) {
- retVal = GL_FALSE;
- break;
+ if (prog->Resident) {
+ if (!allResident)
+ residences[i] = GL_TRUE;
}
- }
-
- /* only write to residences if returning false! */
- if (retVal == GL_FALSE) {
- for (i = 0; i < n; i++) {
- const struct program *prog = (const struct program *)
- _mesa_HashLookup(ctx->Shared->Programs, ids[i]);
- residences[i] = prog->Resident;
+ else {
+ if (allResident) {
+ allResident = GL_FALSE;
+ for (j = 0; j < i; j++)
+ residences[j] = GL_TRUE;
+ }
+ residences[i] = GL_FALSE;
}
}
- return retVal;
+ return allResident;
}
* Request that a set of programs be resident in hardware.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_RequestResidentProgramsNV(GLsizei n, const GLuint *ids)
{
GLint i;
/* just error checking for now */
for (i = 0; i < n; i++) {
- struct program *prog;
+ struct gl_program *prog;
if (ids[i] == 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glRequestResidentProgramsNV(id)");
return;
}
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, ids[i]);
-
+ prog = _mesa_lookup_program(ctx, ids[i]);
if (!prog) {
_mesa_error(ctx, GL_INVALID_VALUE, "glRequestResidentProgramsNV(id)");
return;
}
+ /* XXX this is really a hardware thing we should hook out */
prog->Resident = GL_TRUE;
}
}
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetProgramParameterfvNV(GLenum target, GLuint index,
GLenum pname, GLfloat *params)
{
if (target == GL_VERTEX_PROGRAM_NV) {
if (pname == GL_PROGRAM_PARAMETER_NV) {
if (index < MAX_NV_VERTEX_PROGRAM_PARAMS) {
- index += VP_PROG_REG_START;
- COPY_4V(params, ctx->VertexProgram.Machine.Registers[index]);
+ COPY_4V(params, ctx->VertexProgram.Parameters[index]);
}
else {
_mesa_error(ctx, GL_INVALID_VALUE,
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetProgramParameterdvNV(GLenum target, GLuint index,
GLenum pname, GLdouble *params)
{
if (target == GL_VERTEX_PROGRAM_NV) {
if (pname == GL_PROGRAM_PARAMETER_NV) {
if (index < MAX_NV_VERTEX_PROGRAM_PARAMS) {
- index += VP_PROG_REG_START;
- COPY_4V(params, ctx->VertexProgram.Machine.Registers[index]);
+ COPY_4V(params, ctx->VertexProgram.Parameters[index]);
}
else {
_mesa_error(ctx, GL_INVALID_VALUE,
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetProgramivNV(GLuint id, GLenum pname, GLint *params)
{
- struct program *prog;
+ struct gl_program *prog;
GET_CURRENT_CONTEXT(ctx);
+
ASSERT_OUTSIDE_BEGIN_END(ctx);
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
+ prog = _mesa_lookup_program(ctx, id);
if (!prog) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramivNV");
return;
*params = prog->Target;
return;
case GL_PROGRAM_LENGTH_NV:
- *params = prog->String ? _mesa_strlen((char *) prog->String) : 0;
+ *params = prog->String ?(GLint) strlen((char *) prog->String) : 0;
return;
case GL_PROGRAM_RESIDENT_NV:
*params = prog->Resident;
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
{
- struct program *prog;
+ struct gl_program *prog;
GET_CURRENT_CONTEXT(ctx);
+
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (pname != GL_PROGRAM_STRING_NV) {
- _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivNV(pname)");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringNV(pname)");
return;
}
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
+ prog = _mesa_lookup_program(ctx, id);
if (!prog) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramivNV");
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramStringNV");
return;
}
if (prog->String) {
- MEMCPY(program, prog->String, _mesa_strlen((char *) prog->String));
+ memcpy(program, prog->String, strlen((char *) prog->String));
}
else {
program[0] = 0;
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetTrackMatrixivNV(GLenum target, GLuint address,
GLenum pname, GLint *params)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (target == GL_VERTEX_PROGRAM_NV) {
+ if (target == GL_VERTEX_PROGRAM_NV
+ && ctx->Extensions.NV_vertex_program) {
GLuint i;
if ((address & 0x3) || address >= MAX_NV_VERTEX_PROGRAM_PARAMS) {
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params)
{
+ const struct gl_client_array *array;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (index == 0 || index >= VP_NUM_INPUT_REGS) {
+ if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribdvNV(index)");
return;
}
+ array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
+
switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV:
- params[0] = ctx->Array.VertexAttrib[index].Size;
+ params[0] = array->Size;
break;
case GL_ATTRIB_ARRAY_STRIDE_NV:
- params[0] = ctx->Array.VertexAttrib[index].Stride;
+ params[0] = array->Stride;
break;
case GL_ATTRIB_ARRAY_TYPE_NV:
- params[0] = ctx->Array.VertexAttrib[index].Type;
+ params[0] = array->Type;
break;
case GL_CURRENT_ATTRIB_NV:
+ if (index == 0) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetVertexAttribdvNV(index == 0)");
+ return;
+ }
+ FLUSH_CURRENT(ctx, 0);
COPY_4V(params, ctx->Current.Attrib[index]);
break;
default:
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params)
{
+ const struct gl_client_array *array;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (index == 0 || index >= VP_NUM_INPUT_REGS) {
+ if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribdvNV(index)");
return;
}
+ array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
+
switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV:
- params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Size;
+ params[0] = (GLfloat) array->Size;
break;
case GL_ATTRIB_ARRAY_STRIDE_NV:
- params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Stride;
+ params[0] = (GLfloat) array->Stride;
break;
case GL_ATTRIB_ARRAY_TYPE_NV:
- params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Type;
+ params[0] = (GLfloat) array->Type;
break;
case GL_CURRENT_ATTRIB_NV:
+ if (index == 0) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetVertexAttribfvNV(index == 0)");
+ return;
+ }
+ FLUSH_CURRENT(ctx, 0);
COPY_4V(params, ctx->Current.Attrib[index]);
break;
default:
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetVertexAttribivNV(GLuint index, GLenum pname, GLint *params)
{
+ const struct gl_client_array *array;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (index == 0 || index >= VP_NUM_INPUT_REGS) {
+ if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribdvNV(index)");
return;
}
+ array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
+
switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV:
- params[0] = ctx->Array.VertexAttrib[index].Size;
+ params[0] = array->Size;
break;
case GL_ATTRIB_ARRAY_STRIDE_NV:
- params[0] = ctx->Array.VertexAttrib[index].Stride;
+ params[0] = array->Stride;
break;
case GL_ATTRIB_ARRAY_TYPE_NV:
- params[0] = ctx->Array.VertexAttrib[index].Type;
+ params[0] = array->Type;
break;
case GL_CURRENT_ATTRIB_NV:
- COPY_4V_CAST(params, ctx->Current.Attrib[index], GLint);
+ if (index == 0) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetVertexAttribivNV(index == 0)");
+ return;
+ }
+ FLUSH_CURRENT(ctx, 0);
+ params[0] = (GLint) ctx->Current.Attrib[index][0];
+ params[1] = (GLint) ctx->Current.Attrib[index][1];
+ params[2] = (GLint) ctx->Current.Attrib[index][2];
+ params[3] = (GLint) ctx->Current.Attrib[index][3];
+ break;
+ case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:
+ params[0] = array->BufferObj->Name;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribdvNV");
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_GetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer)
{
GET_CURRENT_CONTEXT(ctx);
return;
}
- *pointer = ctx->Array.VertexAttrib[index].Ptr;;
+ *pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr;
}
-
-/**
- * Determine if id names a program.
- * \note Not compiled into display lists.
- * \note Called from the GL API dispatcher.
- * \param id is the program identifier
- * \return GL_TRUE if id is a program, else GL_FALSE.
- */
-GLboolean _mesa_IsProgramNV(GLuint id)
+void
+_mesa_emit_nv_temp_initialization(struct gl_context *ctx,
+ struct gl_program *program)
{
- struct program *prog;
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+ struct prog_instruction *inst;
+ GLuint i;
+ struct gl_shader_compiler_options* options =
+ &ctx->ShaderCompilerOptions[_mesa_program_target_to_index(program->Target)];
- if (id == 0)
- return GL_FALSE;
+ if (!options->EmitNVTempInitialization)
+ return;
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
- if (prog && prog->Target)
- return GL_TRUE;
- else
- return GL_FALSE;
+ /* We'll swizzle up a zero temporary so we can use it for the
+ * ARL.
+ */
+ if (program->NumTemporaries == 0)
+ program->NumTemporaries = 1;
+
+ _mesa_insert_instructions(program, 0, program->NumTemporaries + 1);
+
+ for (i = 0; i < program->NumTemporaries; i++) {
+ struct prog_instruction *inst = &program->Instructions[i];
+
+ inst->Opcode = OPCODE_SWZ;
+ inst->DstReg.File = PROGRAM_TEMPORARY;
+ inst->DstReg.Index = i;
+ inst->DstReg.WriteMask = WRITEMASK_XYZW;
+ inst->SrcReg[0].File = PROGRAM_TEMPORARY;
+ inst->SrcReg[0].Index = 0;
+ inst->SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_ZERO,
+ SWIZZLE_ZERO,
+ SWIZZLE_ZERO,
+ SWIZZLE_ZERO);
+ }
+
+ inst = &program->Instructions[i];
+ inst->Opcode = OPCODE_ARL;
+ inst->DstReg.File = PROGRAM_ADDRESS;
+ inst->DstReg.Index = 0;
+ inst->DstReg.WriteMask = WRITEMASK_XYZW;
+ inst->SrcReg[0].File = PROGRAM_TEMPORARY;
+ inst->SrcReg[0].Index = 0;
+ inst->SrcReg[0].Swizzle = SWIZZLE_XXXX;
+
+ if (program->NumAddressRegs == 0)
+ program->NumAddressRegs = 1;
}
+void
+_mesa_setup_nv_temporary_count(struct gl_program *program)
+{
+ GLuint i;
+
+ program->NumTemporaries = 0;
+ for (i = 0; i < program->NumInstructions; i++) {
+ struct prog_instruction *inst = &program->Instructions[i];
+
+ if (inst->DstReg.File == PROGRAM_TEMPORARY) {
+ program->NumTemporaries = MAX2(program->NumTemporaries,
+ inst->DstReg.Index + 1);
+ }
+ if (inst->SrcReg[0].File == PROGRAM_TEMPORARY) {
+ program->NumTemporaries = MAX2((GLint)program->NumTemporaries,
+ inst->SrcReg[0].Index + 1);
+ }
+ if (inst->SrcReg[1].File == PROGRAM_TEMPORARY) {
+ program->NumTemporaries = MAX2((GLint)program->NumTemporaries,
+ inst->SrcReg[1].Index + 1);
+ }
+ if (inst->SrcReg[2].File == PROGRAM_TEMPORARY) {
+ program->NumTemporaries = MAX2((GLint)program->NumTemporaries,
+ inst->SrcReg[2].Index + 1);
+ }
+ }
+}
/**
- * Load a program.
+ * Load/parse/compile a program.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
const GLubyte *program)
{
- struct program *prog;
+ struct gl_program *prog;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
+ if (!ctx->Extensions.NV_vertex_program
+ && !ctx->Extensions.NV_fragment_program) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV()");
+ return;
+ }
+
if (id == 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glLoadProgramNV(id)");
return;
}
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
+ if (len < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLoadProgramNV(len)");
+ return;
+ }
+
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+
+ prog = _mesa_lookup_program(ctx, id);
if (prog && prog->Target != 0 && prog->Target != target) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV(target)");
return;
}
- /* Reset error pos and string */
- _mesa_set_program_error(ctx, -1, NULL);
-
- if (target == GL_VERTEX_PROGRAM_NV ||
- target == GL_VERTEX_STATE_PROGRAM_NV) {
- struct vertex_program *vprog = (struct vertex_program *) prog;
- if (!vprog) {
- vprog = CALLOC_STRUCT(vertex_program);
- if (!vprog) {
+ if (target == GL_FRAGMENT_PROGRAM_NV
+ && ctx->Extensions.NV_fragment_program) {
+ struct gl_fragment_program *fprog = gl_fragment_program(prog);
+ if (!fprog || prog == &_mesa_DummyProgram) {
+ fprog = gl_fragment_program(ctx->Driver.NewProgram(ctx, target, id));
+ if (!fprog) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
return;
}
- vprog->Base.RefCount = 1;
- vprog->Base.Resident = GL_TRUE;
- _mesa_HashInsert(ctx->Shared->Programs, id, vprog);
+ _mesa_HashInsert(ctx->Shared->Programs, id, fprog);
}
- _mesa_parse_nv_vertex_program(ctx, target, program, len, vprog);
+ _mesa_parse_nv_fragment_program(ctx, target, program, len, fprog);
}
- else if (target == GL_FRAGMENT_PROGRAM_NV) {
- struct fragment_program *fprog = (struct fragment_program *) prog;
- if (!fprog) {
- fprog = CALLOC_STRUCT(fragment_program);
+ else if (target == GL_FRAGMENT_PROGRAM_ARB
+ && ctx->Extensions.ARB_fragment_program) {
+ struct gl_fragment_program *fprog = gl_fragment_program(prog);
+ if (!fprog || prog == &_mesa_DummyProgram) {
+ fprog = gl_fragment_program(ctx->Driver.NewProgram(ctx, target, id));
if (!fprog) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
return;
}
- fprog->Base.RefCount = 1;
- fprog->Base.Resident = GL_TRUE;
_mesa_HashInsert(ctx->Shared->Programs, id, fprog);
}
- _mesa_parse_nv_fragment_program(ctx, target, program, len, fprog);
- }
- else {
- _mesa_error(ctx, GL_INVALID_ENUM, "LoadProgramNV(target)");
- }
-}
-
-
-
-/**
- * Set a program parameter register.
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_ProgramParameter4dNV(GLenum target, GLuint index,
- GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
- _mesa_ProgramParameter4fNV(target, index,
- (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
-}
-
-
-/**
- * Set a program parameter register.
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_ProgramParameter4dvNV(GLenum target, GLuint index,
- const GLdouble *params)
-{
- _mesa_ProgramParameter4fNV(target, index,
- (GLfloat)params[0], (GLfloat)params[1],
- (GLfloat)params[2], (GLfloat)params[3]);
-}
-
-
-/**
- * Set a program parameter register.
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_ProgramParameter4fNV(GLenum target, GLuint index,
- GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END(ctx);
-
- if (target == GL_VERTEX_PROGRAM_NV) {
- if (index < MAX_NV_VERTEX_PROGRAM_PARAMS) {
- index += VP_PROG_REG_START;
- ASSIGN_4V(ctx->VertexProgram.Machine.Registers[index], x, y, z, w);
- }
- else {
- _mesa_error(ctx, GL_INVALID_VALUE, "glProgramParameterrNV(index)");
- return;
- }
+ _mesa_parse_arb_fragment_program(ctx, target, program, len, fprog);
}
else {
- _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameterrNV");
- return;
+ _mesa_error(ctx, GL_INVALID_ENUM, "glLoadProgramNV(target)");
}
}
-/**
- * Set a program parameter register.
- * \note Called from the GL API dispatcher.
- */
-void
-_mesa_ProgramParameter4fvNV(GLenum target, GLuint index,
- const GLfloat *params)
-{
- _mesa_ProgramParameter4fNV(target, index,
- params[0], params[1], params[2], params[3]);
-}
-
-
/**
* Set a sequence of program parameter registers.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_ProgramParameters4dvNV(GLenum target, GLuint index,
- GLuint num, const GLdouble *params)
+ GLsizei num, const GLdouble *params)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (target == GL_VERTEX_PROGRAM_NV) {
- GLuint i;
+ if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) {
+ GLint i;
if (index + num > MAX_NV_VERTEX_PROGRAM_PARAMS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramParameters4dvNV");
return;
}
- index += VP_PROG_REG_START;
for (i = 0; i < num; i++) {
- COPY_4V_CAST(ctx->VertexProgram.Machine.Registers[index + i],
- params, GLfloat);
+ ctx->VertexProgram.Parameters[index + i][0] = (GLfloat) params[0];
+ ctx->VertexProgram.Parameters[index + i][1] = (GLfloat) params[1];
+ ctx->VertexProgram.Parameters[index + i][2] = (GLfloat) params[2];
+ ctx->VertexProgram.Parameters[index + i][3] = (GLfloat) params[3];
params += 4;
};
}
* Set a sequence of program parameter registers.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_ProgramParameters4fvNV(GLenum target, GLuint index,
- GLuint num, const GLfloat *params)
+ GLsizei num, const GLfloat *params)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (target == GL_VERTEX_PROGRAM_NV) {
- GLuint i;
+ if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) {
+ GLint i;
if (index + num > MAX_NV_VERTEX_PROGRAM_PARAMS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramParameters4fvNV");
return;
}
- index += VP_PROG_REG_START;
for (i = 0; i < num; i++) {
- COPY_4V(ctx->VertexProgram.Machine.Registers[index + i], params);
+ COPY_4V(ctx->VertexProgram.Parameters[index + i], params);
params += 4;
- };
+ }
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameters4fvNV");
* Setup tracking of matrices into program parameter registers.
* \note Called from the GL API dispatcher.
*/
-void
+void GLAPIENTRY
_mesa_TrackMatrixNV(GLenum target, GLuint address,
GLenum matrix, GLenum transform)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (target == GL_VERTEX_PROGRAM_NV) {
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+
+ if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) {
if (address & 0x3) {
/* addr must be multiple of four */
_mesa_error(ctx, GL_INVALID_VALUE, "glTrackMatrixNV(address)");
}
-static GLfloat *
-lookup_program_parameter(struct fragment_program *fprog,
- GLsizei len, const GLubyte *name)
+void GLAPIENTRY
+_mesa_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name,
+ GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
- return NULL;
-}
-
+ struct gl_program *prog;
+ struct gl_fragment_program *fragProg;
+ gl_constant_value *v;
-void
-glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name,
- GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- struct program *prog;
- GLfloat *p;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
+
+ prog = _mesa_lookup_program(ctx, id);
if (!prog || prog->Target != GL_FRAGMENT_PROGRAM_NV) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glProgramNamedParameterNV");
return;
}
if (len <= 0) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV(len)");
return;
}
- p = lookup_program_parameter((struct fragment_program *) prog, len, name);
- if (!p) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV");
+ fragProg = gl_fragment_program(prog);
+ v = _mesa_lookup_parameter_value(fragProg->Base.Parameters, len,
+ (char *) name);
+ if (v) {
+ v[0].f = x;
+ v[1].f = y;
+ v[2].f = z;
+ v[3].f = w;
return;
}
- p[0] = x;
- p[1] = y;
- p[2] = z;
- p[3] = w;
+ _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV(name)");
}
-void
-glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name,
- const float v[])
+void GLAPIENTRY
+_mesa_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name,
+ const float v[])
{
- glProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
+ _mesa_ProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
}
-void
-glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name,
- GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+void GLAPIENTRY
+_mesa_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name,
+ GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
- glProgramNamedParameter4fNV(id, len, name, (GLfloat)x, (GLfloat)y,
- (GLfloat)z, (GLfloat)w);
+ _mesa_ProgramNamedParameter4fNV(id, len, name, (GLfloat)x, (GLfloat)y,
+ (GLfloat)z, (GLfloat)w);
}
-void
-glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name,
- const double v[])
+void GLAPIENTRY
+_mesa_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name,
+ const double v[])
{
- glProgramNamedParameter4fNV(id, len, name, (GLfloat)v[0], (GLfloat)v[1],
- (GLfloat)v[2], (GLfloat)v[3]);
+ _mesa_ProgramNamedParameter4fNV(id, len, name,
+ (GLfloat)v[0], (GLfloat)v[1],
+ (GLfloat)v[2], (GLfloat)v[3]);
}
-void
-glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name,
- GLfloat *params)
+void GLAPIENTRY
+_mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name,
+ GLfloat *params)
{
- struct program *prog;
- const GLfloat *p;
+ struct gl_program *prog;
+ struct gl_fragment_program *fragProg;
+ const gl_constant_value *v;
+
GET_CURRENT_CONTEXT(ctx);
+
ASSERT_OUTSIDE_BEGIN_END(ctx);
- prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id);
+ prog = _mesa_lookup_program(ctx, id);
if (!prog || prog->Target != GL_FRAGMENT_PROGRAM_NV) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramNamedParameterNV");
return;
return;
}
- p = lookup_program_parameter((struct fragment_program *) prog, len, name);
- if (!p) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramNamedParameterNV");
+ fragProg = gl_fragment_program(prog);
+ v = _mesa_lookup_parameter_value(fragProg->Base.Parameters,
+ len, (char *) name);
+ if (v) {
+ params[0] = v[0].f;
+ params[1] = v[1].f;
+ params[2] = v[2].f;
+ params[3] = v[3].f;
return;
}
- params[0] = p[0];
- params[1] = p[1];
- params[2] = p[2];
- params[3] = p[3];
-}
-
-
-void
-glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name,
- GLdouble *params)
-{
- GLfloat floatParams[4];
- glGetProgramNamedParameterfvNV(id, len, name, floatParams);
- COPY_4V(params, floatParams);
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramNamedParameterNV");
}
-void
-glProgramLocalParameter4fARB(GLenum target, GLuint index,
- GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END(ctx);
-
- if (target == GL_FRAGMENT_PROGRAM_NV) {
- struct fragment_program *fprog = ctx->FragmentProgram.Current;
- if (!fprog) {
- _mesa_error(ctx, GL_INVALID_ENUM, "glProgramLocalParameterARB");
- return;
- }
- if (index >= MAX_NV_FRAGMENT_PROGRAM_PARAMS) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB");
- return;
- }
- fprog->LocalParams[index][0] = x;
- fprog->LocalParams[index][1] = y;
- fprog->LocalParams[index][2] = z;
- fprog->LocalParams[index][3] = w;
- }
- else {
- _mesa_error(ctx, GL_INVALID_ENUM, "glProgramLocalParameterARB");
- return;
- }
-}
-
-
-void
-glProgramLocalParameter4fvARB(GLenum target, GLuint index,
- const GLfloat *params)
-{
- glProgramLocalParameter4fARB(target, index, params[0], params[1],
- params[2], params[3]);
-}
-
-
-void
-glProgramLocalParameter4dARB(GLenum target, GLuint index,
- GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
- glProgramLocalParameter4fARB(target, index, (GLfloat)x, (GLfloat)y,
- (GLfloat)z, (GLfloat)w);
-}
-
-
-void
-glProgramLocalParameter4dvARB(GLenum target, GLuint index,
- const GLdouble *params)
-{
- glProgramLocalParameter4fARB(target, index, (GLfloat)params[0],
- (GLfloat)params[1], (GLfloat)params[2],
- (GLfloat)params[3]);
-}
-
-
-void
-glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params)
-{
- GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END(ctx);
-
- if (target == GL_FRAGMENT_PROGRAM_NV) {
- struct fragment_program *fprog = ctx->FragmentProgram.Current;
- if (!fprog) {
- _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramLocalParameterARB");
- return;
- }
- if (index >= MAX_NV_FRAGMENT_PROGRAM_PARAMS) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramLocalParameterARB");
- return;
- }
- params[0] = fprog->LocalParams[index][0];
- params[1] = fprog->LocalParams[index][1];
- params[2] = fprog->LocalParams[index][2];
- params[3] = fprog->LocalParams[index][3];
- }
- else {
- _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramLocalParameterARB");
- return;
- }
-}
-
-
-void
-glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params)
+void GLAPIENTRY
+_mesa_GetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name,
+ GLdouble *params)
{
GLfloat floatParams[4];
- glGetProgramLocalParameterfvARB(target, index, floatParams);
+ _mesa_GetProgramNamedParameterfvNV(id, len, name, floatParams);
COPY_4V(params, floatParams);
}