shaderobjects.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

/*
 * Mesa 3-D graphics library
 * Version:  6.3
 *
 * Copyright (C) 2004-2005  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 shaderobjects.c
 * ARB_shader_objects state management functions
 * \author Michal Krol
 */


#include "glheader.h"
#include "shaderobjects.h"
#include "shaderobjects_3dlabs.h"
#include "context.h"
#include "macros.h"
#include "hash.h"


void GLAPIENTRY
_mesa_DeleteObjectARB (GLhandleARB obj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_generic_intf **gen;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unk = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, obj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unk == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glDeleteObjectARB");
		return;
	}

	gen = (struct gl2_generic_intf **) (**unk).QueryInterface (unk, UIID_GENERIC);
	if (gen == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glDeleteObjectARB");
		return;
	}

	(**gen).Delete (gen);
	(**gen)._unknown.Release ((struct gl2_unknown_intf **) gen);
}

GLhandleARB GLAPIENTRY
_mesa_GetHandleARB (GLenum pname)
{
	GET_CURRENT_CONTEXT(ctx);

	switch (pname)
	{
	case GL_PROGRAM_OBJECT_ARB:
		if (ctx->ShaderObjects.current_program != NULL)
			return (**ctx->ShaderObjects.current_program)._container._generic.GetName (
				(struct gl2_generic_intf **) ctx->ShaderObjects.current_program);
		break;
	}

	return 0;
}

void GLAPIENTRY
_mesa_DetachObjectARB (GLhandleARB containerObj, GLhandleARB attachedObj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unkc, **unka;
	struct gl2_container_intf **con;
	struct gl2_generic_intf **att;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unkc = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, containerObj);
	unka = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, attachedObj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unkc == NULL || unka == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glDetachObjectARB");
		return;
	}

	con = (struct gl2_container_intf **) (**unkc).QueryInterface (unkc, UIID_CONTAINER);
	if (con == NULL)
	{
		_mesa_error (ctx, GL_INVALID_OPERATION, "glDetachObjectARB");
		return;
	}

	att = (struct gl2_generic_intf **) (**unka).QueryInterface (unka, UIID_GENERIC);
	if (att == NULL)
	{
		(**con)._generic._unknown.Release ((struct gl2_unknown_intf **) con);
		_mesa_error (ctx, GL_INVALID_VALUE, "glDetachObjectARB");
		return;
	}

	if ((**con).Detach (con, att) == GL_FALSE)
	{
		(**con)._generic._unknown.Release ((struct gl2_unknown_intf **) con);
		(**att)._unknown.Release ((struct gl2_unknown_intf **) att);
		return;
	}

	(**con)._generic._unknown.Release ((struct gl2_unknown_intf **) con);
	(**att)._unknown.Release ((struct gl2_unknown_intf **) att);
}

GLhandleARB GLAPIENTRY
_mesa_CreateShaderObjectARB (GLenum shaderType)
{
	return _mesa_3dlabs_create_shader_object (shaderType);
}

void GLAPIENTRY
_mesa_ShaderSourceARB (GLhandleARB shaderObj, GLsizei count, const GLcharARB **string,
					   const GLint *length)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_shader_intf **sha;
	GLint *offsets;
	GLsizei i;
	GLcharARB *source;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unk = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, shaderObj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unk == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glShaderSourceARB");
		return;
	}

	sha = (struct gl2_shader_intf **) (**unk).QueryInterface (unk, UIID_SHADER);
	if (sha == NULL)
	{
		_mesa_error (ctx, GL_INVALID_OPERATION, "glShaderSourceARB");
		return;
	}

	/* this array holds offsets of where the appropriate string ends, thus the last
	element will be set to the total length of the source code */
	offsets = (GLint *) _mesa_malloc (count * sizeof (GLint));
	if (offsets == NULL)
	{
		(**sha)._generic._unknown.Release ((struct gl2_unknown_intf **) sha);
		_mesa_error (ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
		return;
	}

	for (i = 0; i < count; i++)
	{
		if (length == NULL || length[i] < 0)
			offsets[i] = _mesa_strlen (string[i]);
		else
			offsets[i] = length[i];
		/* accumulate string lengths */
		if (i > 0)
			offsets[i] += offsets[i - 1];
	}

	source = (GLcharARB *) _mesa_malloc ((offsets[count - 1] + 1) * sizeof (GLcharARB));
	if (source == NULL)
	{
		_mesa_free ((void *) offsets);
		(**sha)._generic._unknown.Release ((struct gl2_unknown_intf **) sha);
		_mesa_error (ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
		return;
	}

	for (i = 0; i < count; i++)
	{
		GLint start = (i > 0) ? offsets[i - 1] : 0;
		_mesa_memcpy (source + start, string[i], (offsets[i] - start) * sizeof (GLcharARB));
	}
	source[offsets[count - 1]] = '\0';

	(**sha).SetSource (sha, source, offsets, count);
	(**sha)._generic._unknown.Release ((struct gl2_unknown_intf **) sha);
}

void  GLAPIENTRY
_mesa_CompileShaderARB (GLhandleARB shaderObj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_shader_intf **sha;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unk = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, shaderObj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unk == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glCompileShaderARB");
		return;
	}

	sha = (struct gl2_shader_intf **) (**unk).QueryInterface (unk, UIID_SHADER);
	if (sha == NULL)
	{
		_mesa_error (ctx, GL_INVALID_OPERATION, "glCompileShaderARB");
		return;
	}

	(**sha).Compile (sha);
	(**sha)._generic._unknown.Release ((struct gl2_unknown_intf **) sha);
}

GLhandleARB GLAPIENTRY
_mesa_CreateProgramObjectARB (void)
{
	return _mesa_3dlabs_create_program_object ();
}

void GLAPIENTRY
_mesa_AttachObjectARB (GLhandleARB containerObj, GLhandleARB obj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unkc, **unka;
	struct gl2_container_intf **con;
	struct gl2_generic_intf **att;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unkc = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, containerObj);
	unka = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, obj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unkc == NULL || unka == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glAttachObjectARB");
		return;
	}

	con = (struct gl2_container_intf **) (**unkc).QueryInterface (unkc, UIID_CONTAINER);
	if (con == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glAttachObjectARB");
		return;
	}

	att = (struct gl2_generic_intf **) (**unka).QueryInterface (unka, UIID_GENERIC);
	if (att == NULL)
	{
		(**con)._generic._unknown.Release ((struct gl2_unknown_intf **) con);
		_mesa_error (ctx, GL_INVALID_VALUE, "glAttachObjectARB");
		return;
	}

	if (!(**con).Attach (con, att))
	{
		(**con)._generic._unknown.Release ((struct gl2_unknown_intf **) con);
		(**att)._unknown.Release ((struct gl2_unknown_intf **) att);
		return;
	}

	(**con)._generic._unknown.Release ((struct gl2_unknown_intf **) con);
	(**att)._unknown.Release ((struct gl2_unknown_intf **) att);
}

void GLAPIENTRY
_mesa_LinkProgramARB (GLhandleARB programObj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_program_intf **pro;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unk = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, programObj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unk == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glLinkProgramARB");
		return;
	}

	pro = (struct gl2_program_intf **) (**unk).QueryInterface (unk, UIID_PROGRAM);
	if (pro == NULL)
	{
		_mesa_error (ctx, GL_INVALID_OPERATION, "glLinkProgramARB");
		return;
	}

	if (pro == ctx->ShaderObjects.current_program)
	{
		/* TODO re-install executable program */
	}

	(**pro).Link (pro);
	(**pro)._container._generic._unknown.Release ((struct gl2_unknown_intf **) pro);
}

void GLAPIENTRY
_mesa_UseProgramObjectARB (GLhandleARB programObj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_program_intf **pro;

	if (programObj == 0)
	{
		pro = NULL;
	}
	else
	{
		struct gl2_unknown_intf **unk;

		_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
		unk = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, programObj);
		_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

		if (unk == NULL)
		{
			_mesa_error (ctx, GL_INVALID_VALUE, "glUseProgramObjectARB");
			return;
		}

		pro = (struct gl2_program_intf **) (**unk).QueryInterface (unk, UIID_PROGRAM);
		if (pro == NULL)
		{
			_mesa_error (ctx, GL_INVALID_OPERATION, "glUseProgramObjectARB");
			return;
		}

		if ((**pro).GetLinkStatus (pro) == GL_FALSE)
		{
			(**pro)._container._generic._unknown.Release ((struct gl2_unknown_intf **) pro);
			_mesa_error (ctx, GL_INVALID_OPERATION, "glUseProgramObjectARB");
			return;
		}
	}

	if (ctx->ShaderObjects.current_program != NULL)
	{
		(**ctx->ShaderObjects.current_program)._container._generic._unknown.Release (
			(struct gl2_unknown_intf **) ctx->ShaderObjects.current_program);
	}

	ctx->ShaderObjects.current_program = pro;
}

void GLAPIENTRY
_mesa_ValidateProgramARB (GLhandleARB programObj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_program_intf **pro;

	_glthread_LOCK_MUTEX (ctx->Shared->Mutex);
	unk = (struct gl2_unknown_intf **) _mesa_HashLookup (ctx->Shared->GL2Objects, programObj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

	if (unk == NULL)
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glValidateProgramARB");
		return;
	}

	pro = (struct gl2_program_intf **) (**unk).QueryInterface (unk, UIID_PROGRAM);
	if (pro == NULL)
	{
		_mesa_error (ctx, GL_INVALID_OPERATION, "glValidateProgramARB");
		return;
	}

	(**pro).Validate (pro);
	(**pro)._container._generic._unknown.Release ((struct gl2_unknown_intf **) pro);
}

/*
Errors TODO