shaderobjects.c

winNT技术操作系统,国外开放的原代码和LIUX一样

			for (i = 0; i < size; i++)
				params[i] = (GLfloat) ((GLint *) params)[i];
}

void GLAPIENTRY
_mesa_GetObjectParameterivARB (GLhandleARB obj, GLenum pname, GLint *params)
{
	GLboolean integral;
	GLint size, i;

	assert (sizeof (GLfloat) == sizeof (GLint));

	if (_mesa_get_object_parameter (obj, pname, (GLvoid *) params, &integral, &size) != GL_FALSE)
		if (integral == GL_FALSE)
			for (i = 0; i < size; i++)
				params[i] = (GLint) ((GLfloat *) params)[i];
}

static void
_mesa_get_string (const GLcharARB *src, GLsizei maxLength, GLsizei *length, GLcharARB *str)
{
	GLsizei len;

	if (src == NULL)
		src = "";

	len = _mesa_strlen (src);
	if (len > maxLength)
	{
		len = maxLength;
		/* allocate space for null termination */
		if (len > 0)
			len--;
	}

	_mesa_memcpy (str, src, len * sizeof (GLcharARB));
	if (maxLength > 0)
		str[len] = '\0';

	if (length != NULL)
		*length = len;
}

void GLAPIENTRY
_mesa_GetInfoLogARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog)
{
	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, "glGetInfoLogARB");
		return;
	}

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

	_mesa_get_string ((**gen).GetInfoLog (gen), maxLength, length, infoLog);

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

void GLAPIENTRY
_mesa_GetAttachedObjectsARB (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_container_intf **con;
	GLsizei cnt, i;

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

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

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

	cnt = (**con).GetAttachedCount (con);
	if (cnt > maxCount)
		cnt = maxCount;

	for (i = 0; i < cnt; i++)
	{
		struct gl2_generic_intf **x = (**con).GetAttached (con, i);
		obj[i] = (**x).GetName (x);
		(**x)._unknown.Release ((struct gl2_unknown_intf **) x);
	}

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

	if (count != NULL)
		*count = cnt;
}

GLint GLAPIENTRY
_mesa_GetUniformLocationARB (GLhandleARB programObj, const GLcharARB *name)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_program_intf **pro;
	GLint loc = -1;

	_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, "glGetUniformLocationARB");
		return -1;
	}

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

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

	/* TODO */

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

void GLAPIENTRY
_mesa_GetActiveUniformARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
{
	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, "glGetActiveUniformARB");
		return;
	}

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

/*	if (index >= val (OBJECT_ACTIVE_ATTRIBUTES_ARB))
	{
		_mesa_error (ctx, GL_INVALID_VALUE, "glGetActiveUniformARB");
		(**pro)._container._generic._unknown.Release ((struct gl2_unknown_intf **) pro);
		return;
	}*/

	/* TODO */

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

void GLAPIENTRY
_mesa_GetUniformfvARB (GLhandleARB programObj, GLint location, GLfloat *params)
{
	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, "glGetUniformfvARB");
		return;
	}

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

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

	/* TODO validate location (OPERATION) */

	/* TODO */

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

void GLAPIENTRY
_mesa_GetUniformivARB (GLhandleARB programObj, GLint location, GLint *params)
{
	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, "glGetUniformivARB");
		return;
	}

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

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

	/* TODO validate location (GL_INVALID_OPERATION) */

	/* TODO */

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

void GLAPIENTRY
_mesa_GetShaderSourceARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source)
{
	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, obj);
	_glthread_UNLOCK_MUTEX (ctx->Shared->Mutex);

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

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

	_mesa_get_string ((**sha).GetSource (sha), maxLength, length, source);

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

/* GL_ARB_vertex_shader */

void GLAPIENTRY
_mesa_BindAttribLocationARB (GLhandleARB programObj, GLuint index, const GLcharARB *name)
{
	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, "glBindAttribLocationARB");
		return;
	}

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

	/* TODO */

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

void GLAPIENTRY
_mesa_GetActiveAttribARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
{
	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, "glGetActiveAttribARB");
		return;
	}

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

	/* TODO */

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

GLint GLAPIENTRY
_mesa_GetAttribLocationARB (GLhandleARB programObj, const GLcharARB *name)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_unknown_intf **unk;
	struct gl2_program_intf **pro;
	GLint loc = 0;

	_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, "glGetAttribLocationARB");
		return 0;
	}

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

	/* TODO */

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

void
_mesa_init_shaderobjects (GLcontext *ctx)
{
	ctx->ShaderObjects.current_program = NULL;

	_mesa_init_shaderobjects_3dlabs (ctx);
}