shaderobjects_3dlabs.c

mesa-6.5-minigui源码

	GLuint addr;

	addr = pro->fragment_fixed_entries[index];
	if (addr != ~0)
	{
		GLubyte *mem;

		mem = (GLubyte *) pro->machines[SLANG_SHADER_FRAGMENT]->mem + addr + offset * size;
		if (write)
			_mesa_memcpy (mem, data, size);
		else
			_mesa_memcpy (data, mem, size);
	}
}

static GLvoid
_program_GetTextureImageUsage (struct gl2_program_intf **intf, GLbitfield *teximageusage)
{
	GET_CURRENT_CONTEXT(ctx);
	struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
	slang_program *pro = &impl->_obj.prog;
	GLuint i;

	for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++)
		teximageusage[i] = 0;

	for (i = 0; i < pro->texture_usage.count; i++)
	{
		GLuint n, addr, j;

		n = pro->texture_usage.table[i].quant->array_len;
		if (n == 0)
			n = 1;
		addr = pro->texture_usage.table[i].frag_address;
		for (j = 0; j < n; j++)
		{
			GLubyte *mem;
			GLuint image;

			mem = (GLubyte *) pro->machines[SLANG_SHADER_FRAGMENT]->mem + addr + j * 4;
			image = (GLuint) *((GLfloat *) mem);
			if (image >= 0 && image < ctx->Const.MaxTextureImageUnits)
			{
				switch (pro->texture_usage.table[i].quant->u.basic_type)
				{
				case GL_SAMPLER_1D_ARB:
				case GL_SAMPLER_1D_SHADOW_ARB:
					teximageusage[image] |= TEXTURE_1D_BIT;
					break;
				case GL_SAMPLER_2D_ARB:
				case GL_SAMPLER_2D_SHADOW_ARB:
					teximageusage[image] |= TEXTURE_2D_BIT;
					break;
				case GL_SAMPLER_3D_ARB:
					teximageusage[image] |= TEXTURE_3D_BIT;
					break;
				case GL_SAMPLER_CUBE_ARB:
					teximageusage[image] |= TEXTURE_CUBE_BIT;
					break;
				}
			}
		}
	}

	/* TODO: make sure that for 0<=i<=MaxTextureImageUint bitcount(teximageuint[i])<=0 */
}

static GLboolean
_program_IsShaderPresent (struct gl2_program_intf **intf, GLenum subtype)
{
	struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
	slang_program *pro = &impl->_obj.prog;

	switch (subtype)
	{
	case GL_VERTEX_SHADER_ARB:
		return pro->machines[SLANG_SHADER_VERTEX] != NULL;
	case GL_FRAGMENT_SHADER_ARB:
		return pro->machines[SLANG_SHADER_FRAGMENT] != NULL;
	default:
		return GL_FALSE;
	}
}

static struct gl2_program_intf _program_vftbl = {
	{
		{
			{
				_unknown_AddRef,
				_unknown_Release,
				_program_QueryInterface
			},
			_generic_Delete,
			_program_GetType,
			_generic_GetName,
			_generic_GetDeleteStatus,
			_generic_GetInfoLog
		},
		_program_Attach,
		_container_Detach,
		_container_GetAttachedCount,
		_container_GetAttached
	},
	_program_GetLinkStatus,
	_program_GetValidateStatus,
	_program_Link,
	_program_Validate,
	_program_UpdateFixedUniforms,
	_program_UpdateFixedAttribute,
	_program_UpdateFixedVarying,
	_program_GetTextureImageUsage,
	_program_IsShaderPresent
};

static void
_program_constructor (struct gl2_program_impl *impl)
{
	_container_constructor ((struct gl2_container_impl *) impl);
	impl->_vftbl = &_program_vftbl;
	impl->_obj._container._generic._unknown._destructor = _program_destructor;
	impl->_obj.link_status = GL_FALSE;
	impl->_obj.validate_status = GL_FALSE;
#if USE_3DLABS_FRONTEND
	impl->_obj.linker = ShConstructLinker (EShExVertexFragment, 0);
	impl->_obj.uniforms = ShConstructUniformMap ();
#endif
	slang_program_ctr (&impl->_obj.prog);
}

struct gl2_fragment_shader_obj
{
	struct gl2_shader_obj _shader;
};

struct gl2_fragment_shader_impl
{
	struct gl2_fragment_shader_intf *_vftbl;
	struct gl2_fragment_shader_obj _obj;
};

static void
_fragment_shader_destructor (struct gl2_unknown_intf **intf)
{
	struct gl2_fragment_shader_impl *impl = (struct gl2_fragment_shader_impl *) intf;

	(void) impl;
	/* TODO free fragment shader data */

	_shader_destructor (intf);
}

static struct gl2_unknown_intf **
_fragment_shader_QueryInterface (struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
{
	if (uiid == UIID_FRAGMENT_SHADER)
	{
		(**intf).AddRef (intf);
		return intf;
	}
	return _shader_QueryInterface (intf, uiid);
}

static GLenum
_fragment_shader_GetSubType (struct gl2_shader_intf **intf)
{
	return GL_FRAGMENT_SHADER_ARB;
}

static struct gl2_fragment_shader_intf _fragment_shader_vftbl = {
	{
		{
			{
				_unknown_AddRef,
				_unknown_Release,
				_fragment_shader_QueryInterface
			},
			_generic_Delete,
			_shader_GetType,
			_generic_GetName,
			_generic_GetDeleteStatus,
			_generic_GetInfoLog
		},
		_fragment_shader_GetSubType,
		_shader_GetCompileStatus,
		_shader_SetSource,
		_shader_GetSource,
		_shader_Compile
	}
};

static void
_fragment_shader_constructor (struct gl2_fragment_shader_impl *impl)
{
	_shader_constructor ((struct gl2_shader_impl *) impl);
	impl->_vftbl = &_fragment_shader_vftbl;
	impl->_obj._shader._generic._unknown._destructor = _fragment_shader_destructor;
#if USE_3DLABS_FRONTEND
	impl->_obj._shader._3dlabs_shhandle._obj.handle = ShConstructCompiler (EShLangFragment, 0);
#endif
}

struct gl2_vertex_shader_obj
{
	struct gl2_shader_obj _shader;
};

struct gl2_vertex_shader_impl
{
	struct gl2_vertex_shader_intf *_vftbl;
	struct gl2_vertex_shader_obj _obj;
};

static void
_vertex_shader_destructor (struct gl2_unknown_intf **intf)
{
	struct gl2_vertex_shader_impl *impl = (struct gl2_vertex_shader_impl *) intf;

	(void) impl;
	/* TODO free vertex shader data */

	_shader_destructor (intf);
}

static struct gl2_unknown_intf **
_vertex_shader_QueryInterface (struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
{
	if (uiid == UIID_VERTEX_SHADER)
	{
		(**intf).AddRef (intf);
		return intf;
	}
	return _shader_QueryInterface (intf, uiid);
}

static GLenum
_vertex_shader_GetSubType (struct gl2_shader_intf **intf)
{
	return GL_VERTEX_SHADER_ARB;
}

static struct gl2_vertex_shader_intf _vertex_shader_vftbl = {
	{
		{
			{
				_unknown_AddRef,
				_unknown_Release,
				_vertex_shader_QueryInterface
			},
			_generic_Delete,
			_shader_GetType,
			_generic_GetName,
			_generic_GetDeleteStatus,
			_generic_GetInfoLog
		},
		_vertex_shader_GetSubType,
		_shader_GetCompileStatus,
		_shader_SetSource,
		_shader_GetSource,
		_shader_Compile
	}
};

static void
_vertex_shader_constructor (struct gl2_vertex_shader_impl *impl)
{
	_shader_constructor ((struct gl2_shader_impl *) impl);
	impl->_vftbl = &_vertex_shader_vftbl;
	impl->_obj._shader._generic._unknown._destructor = _vertex_shader_destructor;
#if USE_3DLABS_FRONTEND
	impl->_obj._shader._3dlabs_shhandle._obj.handle = ShConstructCompiler (EShLangVertex, 0);
#endif
}

GLhandleARB
_mesa_3dlabs_create_shader_object (GLenum shaderType)
{
	switch (shaderType)
	{
	case GL_FRAGMENT_SHADER_ARB:
		{
			struct gl2_fragment_shader_impl *x = (struct gl2_fragment_shader_impl *)
				_mesa_malloc (sizeof (struct gl2_fragment_shader_impl));

			if (x != NULL)
			{
				_fragment_shader_constructor (x);
				return x->_obj._shader._generic.name;
			}
		}
		break;
	case GL_VERTEX_SHADER_ARB:
		{
			struct gl2_vertex_shader_impl *x = (struct gl2_vertex_shader_impl *)
				_mesa_malloc (sizeof (struct gl2_vertex_shader_impl));

			if (x != NULL)
			{
				_vertex_shader_constructor (x);
				return x->_obj._shader._generic.name;
			}
		}
		break;
	}

	return 0;
}

GLhandleARB
_mesa_3dlabs_create_program_object (void)
{
	struct gl2_program_impl *x = (struct gl2_program_impl *) 
		_mesa_malloc (sizeof (struct gl2_program_impl));

	if (x != NULL)
	{
		_program_constructor (x);
		return x->_obj._container._generic.name;
	}

	return 0;
}

#include "slang_assemble.h"
#include "slang_execute.h"

int _slang_fetch_discard (struct gl2_program_intf **pro, GLboolean *val)
{
	struct gl2_program_impl *impl;

	impl = (struct gl2_program_impl *) pro;
	*val = impl->_obj.prog.machines[SLANG_SHADER_FRAGMENT]->kill ? GL_TRUE : GL_FALSE;
	return 1;
}

static GLvoid exec_shader (struct gl2_program_intf **pro, GLuint i)
{
	struct gl2_program_impl *impl;
	slang_program *p;

	impl = (struct gl2_program_impl *) pro;
	p = &impl->_obj.prog;

	slang_machine_init (p->machines[i]);
	p->machines[i]->ip = p->code[i][SLANG_COMMON_CODE_MAIN];

	_slang_execute2 (p->assemblies[i], p->machines[i]);
}

GLvoid _slang_exec_fragment_shader (struct gl2_program_intf **pro)
{
	exec_shader (pro, SLANG_SHADER_FRAGMENT);
}

GLvoid _slang_exec_vertex_shader (struct gl2_program_intf **pro)
{
	exec_shader (pro, SLANG_SHADER_VERTEX);
}

GLint _slang_get_uniform_location (struct gl2_program_intf **pro, const char *name)
{
	struct gl2_program_impl *impl;
	slang_uniform_bindings *bind;
	GLuint i;

	impl = (struct gl2_program_impl *) pro;
	bind = &impl->_obj.prog.uniforms;
	for (i = 0; i < bind->count; i++)
		if (_mesa_strcmp (bind->table[i].name, name) == 0)
			return i;
	return -1;
}

GLboolean _slang_write_uniform (struct gl2_program_intf **pro, GLint loc, GLsizei count,
	const GLvoid *data, GLenum type)
{
	struct gl2_program_impl *impl;
	slang_uniform_bindings *bind;
	slang_uniform_binding *b;
	GLuint i;
	GLboolean convert_float_to_bool = GL_FALSE;
	GLboolean convert_int_to_bool = GL_FALSE;
	GLboolean convert_int_to_float = GL_FALSE;
	GLboolean types_match = GL_FALSE;

	if (loc == -1)
		return GL_TRUE;

	impl = (struct gl2_program_impl *) pro;
	bind = &impl->_obj.prog.uniforms;
	if (loc >= bind->count)
		return GL_FALSE;

	b = &bind->table[loc];
	/* TODO: check sizes */
	if (b->quant->structure != NULL)
		return GL_FALSE;

	switch (b->quant->u.basic_type)
	{
	case GL_BOOL_ARB:
		types_match = (type == GL_FLOAT) || (type == GL_INT);
		if (type == GL_FLOAT)
			convert_float_to_bool = GL_TRUE;
		else
			convert_int_to_bool = GL_TRUE;
		break;
	case GL_BOOL_VEC2_ARB:
		types_match = (type == GL_FLOAT_VEC2_ARB) || (type == GL_INT_VEC2_ARB);
		if (type == GL_FLOAT_VEC2_ARB)
			convert_float_to_bool = GL_TRUE;
		else
			convert_int_to_bool = GL_TRUE;
		break;
	case GL_BOOL_VEC3_ARB:
		types_match = (type == GL_FLOAT_VEC3_ARB) || (type == GL_INT_VEC3_ARB);
		if (type == GL_FLOAT_VEC3_ARB)
			convert_float_to_bool = GL_TRUE;
		else
			convert_int_to_bool = GL_TRUE;
		break;
	case GL_BOOL_VEC4_ARB:
		types_match = (type == GL_FLOAT_VEC4_ARB) || (type == GL_INT_VEC4_ARB);
		if (type == GL_FLOAT_VEC4_ARB)
			convert_float_to_bool = GL_TRUE;
		else
			convert_int_to_bool = GL_TRUE;
		break;
	case GL_SAMPLER_1D_ARB:
	case GL_SAMPLER_2D_ARB:
	case GL_SAMPLER_3D_ARB:
	case GL_SAMPLER_CUBE_ARB:
	case GL_SAMPLER_1D_SHADOW_ARB:
	case GL_SAMPLER_2D_SHADOW_ARB:
		types_match = (type == GL_INT);
		break;
	default:
		types_match = (type == b->quant->u.basic_type);
		break;
	}

	if (!types_match)
		return GL_FALSE;

	switch (type)
	{
	case GL_INT:
	case GL_INT_VEC2_ARB:
	case GL_INT_VEC3_ARB:
	case GL_INT_VEC4_ARB:
		convert_int_to_float = GL_TRUE;
		break;
	}

	if (convert_float_to_bool)
	{
		for (i = 0; i < SLANG_SHADER_MAX; i++)
			if (b->address[i] != ~0)
			{
				const GLfloat *src = (GLfloat *) (data);
				GLfloat *dst = (GLfloat *) (&impl->_obj.prog.machines[i]->mem[b->address[i] / 4]);
				GLuint j;

				for (j = 0; j < count * b->quant->size / 4; j++)
					dst[j] = src[j] != 0.0f ? 1.0f : 0.0f;
			}
	}
	else if (convert_int_to_bool)
	{
		for (i = 0; i < SLANG_SHADER_MAX; i++)
			if (b->address[i] != ~0)
			{
				const GLuint *src = (GLuint *) (data);
				GLfloat *dst = (GLfloat *) (&impl->_obj.prog.machines[i]->mem[b->address[i] / 4]);
				GLuint j;

				for (j = 0; j < count * b->quant->size / 4; j++)
					dst[j] = src[j] ? 1.0f : 0.0f;
			}
	}
	else if (convert_int_to_float)
	{
		for (i = 0; i < SLANG_SHADER_MAX; i++)
			if (b->address[i] != ~0)
			{
				const GLuint *src = (GLuint *) (data);
				GLfloat *dst = (GLfloat *) (&impl->_obj.prog.machines[i]->mem[b->address[i] / 4]);
				GLuint j;

				for (j = 0; j < count * b->quant->size / 4; j++)
					dst[j] = (GLfloat) src[j];
			}
	}
	else
	{
		for (i = 0; i < SLANG_SHADER_MAX; i++)
			if (b->address[i] != ~0)
			{
				_mesa_memcpy (&impl->_obj.prog.machines[i]->mem[b->address[i] / 4], data,
					count * b->quant->size);
			}
	}
	return GL_TRUE;
}

GLuint _slang_get_active_uniform_count (struct gl2_program_intf **pro)
{
	struct gl2_program_impl *impl;

	impl = (struct gl2_program_impl *) pro;
	return impl->_obj.prog.active_uniforms.count;
}

GLuint _slang_get_active_uniform_max_length (struct gl2_program_intf **pro)
{
	struct gl2_program_impl *impl;
	GLuint i, len = 0;

	impl = (struct gl2_program_impl *) pro;
	for (i = 0; i < impl->_obj.prog.active_uniforms.count; i++)
	{
		GLuint n = _mesa_strlen (impl->_obj.prog.active_uniforms.table[i].name);
		if (n > len)
			len = n;
	}
	return len;
}

GLvoid _slang_get_active_uniform (struct gl2_program_intf **pro, GLuint index, GLsizei maxLength,
	GLsizei *length, GLint *size, GLenum *type, char *name)
{
	struct gl2_program_impl *impl;
	slang_active_uniform *u;
	GLsizei len;

	impl = (struct gl2_program_impl *) pro;
	u = &impl->_obj.prog.active_uniforms.table[index];

	len = _mesa_strlen (u->name);
	if (len >= maxLength)
		len = maxLength - 1;
	_mesa_memcpy (name, u->name, len);
	name[len] = '\0';
	if (length != NULL)
		*length = len;
	*type = u->quant->u.basic_type;
	if (u->quant->array_len == 0)
		*size = 1;
	else
		*size = u->quant->array_len;
}

void
_mesa_init_shaderobjects_3dlabs (GLcontext *ctx)
{
#if USE_3DLABS_FRONTEND
	_glslang_3dlabs_InitProcess ();
	_glslang_3dlabs_ShInitialize ();
#endif
}