fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-07 04:58:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

mesa: Remove the NV program API functions.

Browse source 
These are all unused now.

Reviewed-by: Brian Paul <brianp@vmware.com>
Reviewed-by: Eric Anholt <eric@anholt.net>
This commit is contained in:
Kenneth Graunke 2012-10-14 15:02:04 -07:00
parent 16d8161962
commit 7487b16128
6 changed files with 0 additions and 579 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/mesa/SConscript
View file

@ -90,7 +90,6 @@ main_sources = [
'main/mipmap.c',
'main/mm.c',
'main/multisample.c',
'main/nvprogram.c',
'main/pack.c',
'main/pbo.c',
'main/pixel.c',

1
src/mesa/main/api_exec.c
View file

@ -87,7 +87,6 @@
#include "mtypes.h"
#include "varray.h"
#include "viewport.h"
#include "nvprogram.h"
#include "shaderapi.h"
#include "uniforms.h"
#include "syncobj.h"

1
src/mesa/main/dlist.c
View file

@ -63,7 +63,6 @@
#include "mtypes.h"
#include "varray.h"
#include "arbprogram.h"
#include "nvprogram.h"
#include "transformfeedback.h"
#include "math/m_matrix.h"

489
src/mesa/main/nvprogram.c
View file

@ -1,489 +0,0 @@
/*
* Mesa 3-D graphics library
* Version: 6.5.2
*
* 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"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**
* \file nvprogram.c
* NVIDIA vertex/fragment program state management functions.
* \author Brian Paul
*/
/*
* 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.
*/
#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"
/**
* Determine if a set of programs is resident in hardware.
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
GLboolean GLAPIENTRY
_mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids,
GLboolean *residences)
{
GLint i, j;
GLboolean allResident = GL_TRUE;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
if (n < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV(n)");
return GL_FALSE;
}
for (i = 0; i < n; i++) {
const struct gl_program *prog;
if (ids[i] == 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV");
return GL_FALSE;
}
prog = _mesa_lookup_program(ctx, ids[i]);
if (!prog) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV");
return GL_FALSE;
}
if (prog->Resident) {
if (!allResident)
residences[i] = GL_TRUE;
}
else {
if (allResident) {
allResident = GL_FALSE;
for (j = 0; j < i; j++)
residences[j] = GL_TRUE;
}
residences[i] = GL_FALSE;
}
}
return allResident;
}
/**
* Request that a set of programs be resident in hardware.
* \note Called from the GL API dispatcher.
*/
void GLAPIENTRY
_mesa_RequestResidentProgramsNV(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, "glRequestResidentProgramsNV(n)");
return;
}
/* just error checking for now */
for (i = 0; i < n; i++) {
struct gl_program *prog;
if (ids[i] == 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glRequestResidentProgramsNV(id)");
return;
}
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;
}
}
/**
* Get a program attribute.
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
void GLAPIENTRY
_mesa_GetProgramivNV(GLuint id, GLenum pname, GLint *params)
{
struct gl_program *prog;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
prog = _mesa_lookup_program(ctx, id);
if (!prog) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramivNV");
return;
}
switch (pname) {
case GL_PROGRAM_TARGET_NV:
*params = prog->Target;
return;
case GL_PROGRAM_LENGTH_NV:
*params = prog->String ?(GLint) strlen((char *) prog->String) : 0;
return;
case GL_PROGRAM_RESIDENT_NV:
*params = prog->Resident;
return;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivNV(pname)");
return;
}
}
/**
* Get the program source code.
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
void GLAPIENTRY
_mesa_GetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
{
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, "glGetProgramStringNV(pname)");
return;
}
prog = _mesa_lookup_program(ctx, id);
if (!prog) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramStringNV");
return;
}
if (prog->String) {
memcpy(program, prog->String, strlen((char *) prog->String));
}
else {
program[0] = 0;
}
}
/**
* Get a vertex array attribute pointer.
*
* While the function first appeared in GL_NV_vertex_program, it's
* aliased for use by GL_ARB_vertex_program.
*
* \note Not compiled into display lists.
* \note Called from the GL API dispatcher.
*/
void GLAPIENTRY
_mesa_GetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (index >= MAX_VERTEX_GENERIC_ATTRIBS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerNV(index)");
return;
}
if (pname != GL_ATTRIB_ARRAY_POINTER_NV) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribPointerNV(pname)");
return;
}
*pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr;
}
void
_mesa_emit_nv_temp_initialization(struct gl_context *ctx,
struct gl_program *program)
{
struct prog_instruction *inst;
GLuint i;
struct gl_shader_compiler_options* options =
&ctx->ShaderCompilerOptions[_mesa_program_target_to_index(program->Target)];
if (!options->EmitNVTempInitialization)
return;
/* 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/parse/compile a program.
* \note Called from the GL API dispatcher.
*/
void GLAPIENTRY
_mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
const GLubyte *program)
{
struct gl_program *prog;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (!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;
}
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;
}
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;
}
_mesa_HashInsert(ctx->Shared->Programs, id, fprog);
}
_mesa_parse_nv_fragment_program(ctx, target, program, len, fprog);
}
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;
}
_mesa_HashInsert(ctx->Shared->Programs, id, fprog);
}
_mesa_parse_arb_fragment_program(ctx, target, program, len, fprog);
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glLoadProgramNV(target)");
}
}
void GLAPIENTRY
_mesa_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name,
GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
struct gl_program *prog;
struct gl_fragment_program *fragProg;
gl_constant_value *v;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
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(len)");
return;
}
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;
}
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV(name)");
}
void GLAPIENTRY
_mesa_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name,
const float v[])
{
_mesa_ProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
}
void GLAPIENTRY
_mesa_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name,
GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
_mesa_ProgramNamedParameter4fNV(id, len, name, (GLfloat)x, (GLfloat)y,
(GLfloat)z, (GLfloat)w);
}
void GLAPIENTRY
_mesa_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name,
const double v[])
{
_mesa_ProgramNamedParameter4fNV(id, len, name,
(GLfloat)v[0], (GLfloat)v[1],
(GLfloat)v[2], (GLfloat)v[3]);
}
void GLAPIENTRY
_mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name,
GLfloat *params)
{
struct gl_program *prog;
struct gl_fragment_program *fragProg;
const gl_constant_value *v;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
prog = _mesa_lookup_program(ctx, id);
if (!prog || prog->Target != GL_FRAGMENT_PROGRAM_NV) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramNamedParameterNV");
return;
}
if (len <= 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramNamedParameterNV");
return;
}
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;
}
_mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramNamedParameterNV");
}
void GLAPIENTRY
_mesa_GetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name,
GLdouble *params)
{
GLfloat floatParams[4];
_mesa_GetProgramNamedParameterfvNV(id, len, name, floatParams);
COPY_4V(params, floatParams);
}

86
src/mesa/main/nvprogram.h
View file

@ -1,86 +0,0 @@
/*
* Mesa 3-D graphics library
* Version: 5.1
*
* Copyright (C) 1999-2003 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"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Brian Paul
*/
#ifndef NVPROGRAM_H
#define NVPROGRAM_H
#include "glheader.h"
struct gl_context;
struct gl_program;
extern GLboolean GLAPIENTRY
_mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids, GLboolean *residences);
extern void GLAPIENTRY
_mesa_RequestResidentProgramsNV(GLsizei n, const GLuint *ids);
extern void GLAPIENTRY
_mesa_GetProgramivNV(GLuint id, GLenum pname, GLint *params);
extern void GLAPIENTRY
_mesa_GetProgramStringNV(GLuint id, GLenum pname, GLubyte *program);
extern void GLAPIENTRY
_mesa_GetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer);
extern void GLAPIENTRY
_mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program);
extern void GLAPIENTRY
_mesa_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name,
GLfloat x, GLfloat y, GLfloat z, GLfloat w);
extern void GLAPIENTRY
_mesa_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name,
const float v[]);
extern void GLAPIENTRY
_mesa_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name,
GLdouble x, GLdouble y, GLdouble z, GLdouble w);
extern void GLAPIENTRY
_mesa_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name,
const double v[]);
extern void GLAPIENTRY
_mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name,
GLfloat *params);
extern void GLAPIENTRY
_mesa_GetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name,
GLdouble *params);
extern void
_mesa_setup_nv_temporary_count(struct gl_program *program);
extern void
_mesa_emit_nv_temp_initialization(struct gl_context *ctx,
struct gl_program *program);
#endif

1
src/mesa/sources.mak
View file

@ -60,7 +60,6 @@ MAIN_FILES = \
$(SRCDIR)main/mipmap.c \
$(SRCDIR)main/mm.c \
$(SRCDIR)main/multisample.c \
$(SRCDIR)main/nvprogram.c \
$(SRCDIR)main/pack.c \
$(SRCDIR)main/pbo.c \
$(SRCDIR)main/pixel.c \