WebSVN – Kolibri OS – Blame – /programs/develop/libraries/Mesa/src/mesa/main/atifragshader.c

Rev	Author	Line No.	Line
1901	serge	1	/**
		2	* \file atifragshader.c
		3	* \author David Airlie
		4	* Copyright (C) 2004 David Airlie All Rights Reserved.
		5	*
		6	* Permission is hereby granted, free of charge, to any person obtaining a
		7	* copy of this software and associated documentation files (the "Software"),
		8	* to deal in the Software without restriction, including without limitation
		9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		10	* and/or sell copies of the Software, and to permit persons to whom the
		11	* Software is furnished to do so, subject to the following conditions:
		12	*
		13	* The above copyright notice and this permission notice shall be included
		14	* in all copies or substantial portions of the Software.
		15	*
		16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		17	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		19	* DAVID AIRLIE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		20	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		21	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		22	*/
		23
		24	#include "main/glheader.h"
		25	#include "main/context.h"
		26	#include "main/hash.h"
		27	#include "main/imports.h"
		28	#include "main/macros.h"
		29	#include "main/enums.h"
		30	#include "main/mtypes.h"
		31	#include "main/dispatch.h"
		32	#include "main/atifragshader.h"
		33
		34	#if FEATURE_ATI_fragment_shader
		35
		36	#define MESA_DEBUG_ATI_FS 0
		37
		38	static struct ati_fragment_shader DummyShader;
		39
		40
		41	void
		42	_mesa_init_ati_fragment_shader_dispatch(struct _glapi_table *disp)
		43	{
		44	SET_GenFragmentShadersATI(disp, _mesa_GenFragmentShadersATI);
		45	SET_BindFragmentShaderATI(disp, _mesa_BindFragmentShaderATI);
		46	SET_DeleteFragmentShaderATI(disp, _mesa_DeleteFragmentShaderATI);
		47	SET_BeginFragmentShaderATI(disp, _mesa_BeginFragmentShaderATI);
		48	SET_EndFragmentShaderATI(disp, _mesa_EndFragmentShaderATI);
		49	SET_PassTexCoordATI(disp, _mesa_PassTexCoordATI);
		50	SET_SampleMapATI(disp, _mesa_SampleMapATI);
		51	SET_ColorFragmentOp1ATI(disp, _mesa_ColorFragmentOp1ATI);
		52	SET_ColorFragmentOp2ATI(disp, _mesa_ColorFragmentOp2ATI);
		53	SET_ColorFragmentOp3ATI(disp, _mesa_ColorFragmentOp3ATI);
		54	SET_AlphaFragmentOp1ATI(disp, _mesa_AlphaFragmentOp1ATI);
		55	SET_AlphaFragmentOp2ATI(disp, _mesa_AlphaFragmentOp2ATI);
		56	SET_AlphaFragmentOp3ATI(disp, _mesa_AlphaFragmentOp3ATI);
		57	SET_SetFragmentShaderConstantATI(disp, _mesa_SetFragmentShaderConstantATI);
		58	}
		59
		60
		61	/**
		62	* Allocate and initialize a new ATI fragment shader object.
		63	*/
		64	struct ati_fragment_shader *
		65	_mesa_new_ati_fragment_shader(struct gl_context *ctx, GLuint id)
		66	{
		67	struct ati_fragment_shader *s = CALLOC_STRUCT(ati_fragment_shader);
		68	(void) ctx;
		69	if (s) {
		70	s->Id = id;
		71	s->RefCount = 1;
		72	}
		73	return s;
		74	}
		75
		76
		77	/**
		78	* Delete the given ati fragment shader
		79	*/
		80	void
		81	_mesa_delete_ati_fragment_shader(struct gl_context ctx, struct ati_fragment_shader s)
		82	{
		83	GLuint i;
		84	for (i = 0; i < MAX_NUM_PASSES_ATI; i++) {
		85	if (s->Instructions[i])
		86	free(s->Instructions[i]);
		87	if (s->SetupInst[i])
		88	free(s->SetupInst[i]);
		89	}
		90	free(s);
		91	}
		92
		93
		94
		95	static void
		96	new_arith_inst(struct ati_fragment_shader *prog)
		97	{
		98	/* set "default" instruction as not all may get defined.
		99	there is no specified way to express a nop with ati fragment shaders we use
		100	GL_NONE as the op enum and just set some params to 0 - so nothing to do here */
		101	prog->numArithInstr[prog->cur_pass >> 1]++;
		102	}
		103
		104	static void
		105	new_tex_inst(struct ati_fragment_shader *prog)
		106	{
		107	}
		108
		109	static void match_pair_inst(struct ati_fragment_shader *curProg, GLuint optype)
		110	{
		111	if (optype == curProg->last_optype) {
		112	curProg->last_optype = 1;
		113	}
		114	}
		115
		116	#if MESA_DEBUG_ATI_FS
		117	static char *
		118	create_dst_mod_str(GLuint mod)
		119	{
		120	static char ret_str[1024];
		121
		122	memset(ret_str, 0, 1024);
		123	if (mod & GL_2X_BIT_ATI)
		124	strncat(ret_str, "\|2X", 1024);
		125
		126	if (mod & GL_4X_BIT_ATI)
		127	strncat(ret_str, "\|4X", 1024);
		128
		129	if (mod & GL_8X_BIT_ATI)
		130	strncat(ret_str, "\|8X", 1024);
		131	if (mod & GL_HALF_BIT_ATI)
		132	strncat(ret_str, "\|HA", 1024);
		133	if (mod & GL_QUARTER_BIT_ATI)
		134	strncat(ret_str, "\|QU", 1024);
		135	if (mod & GL_EIGHTH_BIT_ATI)
		136	strncat(ret_str, "\|EI", 1024);
		137
		138	if (mod & GL_SATURATE_BIT_ATI)
		139	strncat(ret_str, "\|SAT", 1024);
		140
		141	if (strlen(ret_str) == 0)
		142	strncat(ret_str, "NONE", 1024);
		143	return ret_str;
		144	}
		145
		146	static char *atifs_ops[] = {"ColorFragmentOp1ATI", "ColorFragmentOp2ATI", "ColorFragmentOp3ATI",
		147	"AlphaFragmentOp1ATI", "AlphaFragmentOp2ATI", "AlphaFragmentOp3ATI" };
		148
		149	static void debug_op(GLint optype, GLuint arg_count, GLenum op, GLuint dst,
		150	GLuint dstMask, GLuint dstMod, GLuint arg1,
		151	GLuint arg1Rep, GLuint arg1Mod, GLuint arg2,
		152	GLuint arg2Rep, GLuint arg2Mod, GLuint arg3,
		153	GLuint arg3Rep, GLuint arg3Mod)
		154	{
		155	char *op_name;
		156
		157	op_name = atifs_ops[(arg_count-1)+(optype?3:0)];
		158
		159	fprintf(stderr, "%s(%s, %s", op_name, _mesa_lookup_enum_by_nr(op),
		160	_mesa_lookup_enum_by_nr(dst));
		161	if (!optype)
		162	fprintf(stderr, ", %d", dstMask);
		163
		164	fprintf(stderr, ", %s", create_dst_mod_str(dstMod));
		165
		166	fprintf(stderr, ", %s, %s, %d", _mesa_lookup_enum_by_nr(arg1),
		167	_mesa_lookup_enum_by_nr(arg1Rep), arg1Mod);
		168	if (arg_count>1)
		169	fprintf(stderr, ", %s, %s, %d", _mesa_lookup_enum_by_nr(arg2),
		170	_mesa_lookup_enum_by_nr(arg2Rep), arg2Mod);
		171	if (arg_count>2)
		172	fprintf(stderr, ", %s, %s, %d", _mesa_lookup_enum_by_nr(arg3),
		173	_mesa_lookup_enum_by_nr(arg3Rep), arg3Mod);
		174
		175	fprintf(stderr,")\n");
		176
		177	}
		178	#endif
		179
		180	static int check_arith_arg(struct ati_fragment_shader *curProg,
		181	GLuint optype, GLuint arg, GLuint argRep)
		182	{
		183	GET_CURRENT_CONTEXT(ctx);
		184
		185	if (((arg < GL_CON_0_ATI) \|\| (arg > GL_CON_7_ATI)) &&
		186	((arg < GL_REG_0_ATI) \|\| (arg > GL_REG_5_ATI)) &&
		187	(arg != GL_ZERO) && (arg != GL_ONE) &&
		188	(arg != GL_PRIMARY_COLOR_ARB) && (arg != GL_SECONDARY_INTERPOLATOR_ATI)) {
		189	_mesa_error(ctx, GL_INVALID_ENUM, "C/AFragmentOpATI(arg)");
		190	return 0;
		191	}
		192	if ((arg == GL_SECONDARY_INTERPOLATOR_ATI) && (((optype == 0) && (argRep == GL_ALPHA)) \|\|
		193	((optype == 1) && ((arg == GL_ALPHA) \|\| (argRep == GL_NONE))))) {
		194	_mesa_error(ctx, GL_INVALID_OPERATION, "C/AFragmentOpATI(sec_interp)");
		195	return 0;
		196	}
		197	if ((arg == GL_SECONDARY_INTERPOLATOR_ATI) && (((optype == 0) && (argRep == GL_ALPHA)) \|\|
		198	((optype == 1) && ((arg == GL_ALPHA) \|\| (argRep == GL_NONE))))) {
		199	_mesa_error(ctx, GL_INVALID_OPERATION, "C/AFragmentOpATI(sec_interp)");
		200	return 0;
		201	}
		202	if ((curProg->cur_pass == 1) &&
		203	((arg == GL_PRIMARY_COLOR_ARB) \|\| (arg == GL_SECONDARY_INTERPOLATOR_ATI))) {
		204	curProg->interpinp1 = GL_TRUE;
		205	}
		206	return 1;
		207	}
		208
		209	GLuint GLAPIENTRY
		210	_mesa_GenFragmentShadersATI(GLuint range)
		211	{
		212	GLuint first;
		213	GLuint i;
		214	GET_CURRENT_CONTEXT(ctx);
		215
		216	if (range == 0) {
		217	_mesa_error(ctx, GL_INVALID_VALUE, "glGenFragmentShadersATI(range)");
		218	return 0;
		219	}
		220
		221	if (ctx->ATIFragmentShader.Compiling) {
		222	_mesa_error(ctx, GL_INVALID_OPERATION, "glGenFragmentShadersATI(insideShader)");
		223	return 0;
		224	}
		225
		226	first = _mesa_HashFindFreeKeyBlock(ctx->Shared->ATIShaders, range);
		227	for (i = 0; i < range; i++) {
		228	_mesa_HashInsert(ctx->Shared->ATIShaders, first + i, &DummyShader);
		229	}
		230
		231	return first;
		232	}
		233
		234	void GLAPIENTRY
		235	_mesa_BindFragmentShaderATI(GLuint id)
		236	{
		237	GET_CURRENT_CONTEXT(ctx);
		238	struct ati_fragment_shader *curProg = ctx->ATIFragmentShader.Current;
		239	struct ati_fragment_shader *newProg;
		240
		241	if (ctx->ATIFragmentShader.Compiling) {
		242	_mesa_error(ctx, GL_INVALID_OPERATION, "glBindFragmentShaderATI(insideShader)");
		243	return;
		244	}
		245
		246	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		247
		248	if (curProg->Id == id) {
		249	return;
		250	}
		251
		252	/* unbind current */
		253	if (curProg->Id != 0) {
		254	curProg->RefCount--;
		255	if (curProg->RefCount <= 0) {
		256	_mesa_HashRemove(ctx->Shared->ATIShaders, id);
		257	}
		258	}
		259
		260	/* find new shader */
		261	if (id == 0) {
		262	newProg = ctx->Shared->DefaultFragmentShader;
		263	}
		264	else {
		265	newProg = (struct ati_fragment_shader *)
		266	_mesa_HashLookup(ctx->Shared->ATIShaders, id);
		267	if (!newProg \|\| newProg == &DummyShader) {
		268	/* allocate a new program now */
		269	newProg = _mesa_new_ati_fragment_shader(ctx, id);
		270	if (!newProg) {
		271	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindFragmentShaderATI");
		272	return;
		273	}
		274	_mesa_HashInsert(ctx->Shared->ATIShaders, id, newProg);
		275	}
		276
		277	}
		278
		279	/* do actual bind */
		280	ctx->ATIFragmentShader.Current = newProg;
		281
		282	ASSERT(ctx->ATIFragmentShader.Current);
		283	if (newProg)
		284	newProg->RefCount++;
		285
		286	/*if (ctx->Driver.BindProgram)
		287	ctx->Driver.BindProgram(ctx, target, prog); */
		288	}
		289
		290	void GLAPIENTRY
		291	_mesa_DeleteFragmentShaderATI(GLuint id)
		292	{
		293	GET_CURRENT_CONTEXT(ctx);
		294
		295	if (ctx->ATIFragmentShader.Compiling) {
		296	_mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteFragmentShaderATI(insideShader)");
		297	return;
		298	}
		299
		300	if (id != 0) {
		301	struct ati_fragment_shader prog = (struct ati_fragment_shader )
		302	_mesa_HashLookup(ctx->Shared->ATIShaders, id);
		303	if (prog == &DummyShader) {
		304	_mesa_HashRemove(ctx->Shared->ATIShaders, id);
		305	}
		306	else if (prog) {
		307	if (ctx->ATIFragmentShader.Current &&
		308	ctx->ATIFragmentShader.Current->Id == id) {
		309	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		310	_mesa_BindFragmentShaderATI(0);
		311	}
		312	}
		313
		314	/* The ID is immediately available for re-use now */
		315	_mesa_HashRemove(ctx->Shared->ATIShaders, id);
		316	if (prog) {
		317	prog->RefCount--;
		318	if (prog->RefCount <= 0) {
		319	free(prog);
		320	}
		321	}
		322	}
		323	}
		324
		325
		326	void GLAPIENTRY
		327	_mesa_BeginFragmentShaderATI(void)
		328	{
		329	GLint i;
		330	GET_CURRENT_CONTEXT(ctx);
		331
		332	if (ctx->ATIFragmentShader.Compiling) {
		333	_mesa_error(ctx, GL_INVALID_OPERATION, "glBeginFragmentShaderATI(insideShader)");
		334	return;
		335	}
		336
		337	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		338
		339	/* if the shader was already defined free instructions and get new ones
		340	(or, could use the same mem but would need to reinitialize) */
		341	/* no idea if it's allowed to redefine a shader */
		342	for (i = 0; i < MAX_NUM_PASSES_ATI; i++) {
		343	if (ctx->ATIFragmentShader.Current->Instructions[i])
		344	free(ctx->ATIFragmentShader.Current->Instructions[i]);
		345	if (ctx->ATIFragmentShader.Current->SetupInst[i])
		346	free(ctx->ATIFragmentShader.Current->SetupInst[i]);
		347	}
		348
		349	/* malloc the instructions here - not sure if the best place but its
		350	a start */
		351	for (i = 0; i < MAX_NUM_PASSES_ATI; i++) {
		352	ctx->ATIFragmentShader.Current->Instructions[i] =
		353	(struct atifs_instruction *)
		354	calloc(1, sizeof(struct atifs_instruction) *
		355	(MAX_NUM_INSTRUCTIONS_PER_PASS_ATI));
		356	ctx->ATIFragmentShader.Current->SetupInst[i] =
		357	(struct atifs_setupinst *)
		358	calloc(1, sizeof(struct atifs_setupinst) *
		359	(MAX_NUM_FRAGMENT_REGISTERS_ATI));
		360	}
		361
		362	/* can't rely on calloc for initialization as it's possible to redefine a shader (?) */
		363	ctx->ATIFragmentShader.Current->LocalConstDef = 0;
		364	ctx->ATIFragmentShader.Current->numArithInstr[0] = 0;
		365	ctx->ATIFragmentShader.Current->numArithInstr[1] = 0;
		366	ctx->ATIFragmentShader.Current->regsAssigned[0] = 0;
		367	ctx->ATIFragmentShader.Current->regsAssigned[1] = 0;
		368	ctx->ATIFragmentShader.Current->NumPasses = 0;
		369	ctx->ATIFragmentShader.Current->cur_pass = 0;
		370	ctx->ATIFragmentShader.Current->last_optype = 0;
		371	ctx->ATIFragmentShader.Current->interpinp1 = GL_FALSE;
		372	ctx->ATIFragmentShader.Current->isValid = GL_FALSE;
		373	ctx->ATIFragmentShader.Current->swizzlerq = 0;
		374	ctx->ATIFragmentShader.Compiling = 1;
		375	}
		376
		377	void GLAPIENTRY
		378	_mesa_EndFragmentShaderATI(void)
		379	{
		380	GET_CURRENT_CONTEXT(ctx);
		381	struct ati_fragment_shader *curProg = ctx->ATIFragmentShader.Current;
		382	#if MESA_DEBUG_ATI_FS
		383	GLint i, j;
		384	#endif
		385
		386	if (!ctx->ATIFragmentShader.Compiling) {
		387	_mesa_error(ctx, GL_INVALID_OPERATION, "glEndFragmentShaderATI(outsideShader)");
		388	return;
		389	}
		390	if (curProg->interpinp1 && (ctx->ATIFragmentShader.Current->cur_pass > 1)) {
		391	_mesa_error(ctx, GL_INVALID_OPERATION, "glEndFragmentShaderATI(interpinfirstpass)");
		392	/* according to spec, DON'T return here */
		393	}
		394
		395	match_pair_inst(curProg, 0);
		396	ctx->ATIFragmentShader.Compiling = 0;
		397	ctx->ATIFragmentShader.Current->isValid = GL_TRUE;
		398	if ((ctx->ATIFragmentShader.Current->cur_pass == 0) \|\|
		399	(ctx->ATIFragmentShader.Current->cur_pass == 2)) {
		400	_mesa_error(ctx, GL_INVALID_OPERATION, "glEndFragmentShaderATI(noarithinst)");
		401	}
		402	if (ctx->ATIFragmentShader.Current->cur_pass > 1)
		403	ctx->ATIFragmentShader.Current->NumPasses = 2;
		404	else
		405	ctx->ATIFragmentShader.Current->NumPasses = 1;
		406
		407	ctx->ATIFragmentShader.Current->cur_pass = 0;
		408
		409	#if MESA_DEBUG_ATI_FS
		410	for (j = 0; j < MAX_NUM_PASSES_ATI; j++) {
		411	for (i = 0; i < MAX_NUM_FRAGMENT_REGISTERS_ATI; i++) {
		412	GLuint op = curProg->SetupInst[j][i].Opcode;
		413	const char *op_enum = op > 5 ? _mesa_lookup_enum_by_nr(op) : "0";
		414	GLuint src = curProg->SetupInst[j][i].src;
		415	GLuint swizzle = curProg->SetupInst[j][i].swizzle;
		416	fprintf(stderr, "%2d %04X %s %d %04X\n", i, op, op_enum, src,
		417	swizzle);
		418	}
		419	for (i = 0; i < curProg->numArithInstr[j]; i++) {
		420	GLuint op0 = curProg->Instructions[j][i].Opcode[0];
		421	GLuint op1 = curProg->Instructions[j][i].Opcode[1];
		422	const char *op0_enum = op0 > 5 ? _mesa_lookup_enum_by_nr(op0) : "0";
		423	const char *op1_enum = op1 > 5 ? _mesa_lookup_enum_by_nr(op1) : "0";
		424	GLuint count0 = curProg->Instructions[j][i].ArgCount[0];
		425	GLuint count1 = curProg->Instructions[j][i].ArgCount[1];
		426	fprintf(stderr, "%2d %04X %s %d %04X %s %d\n", i, op0, op0_enum, count0,
		427	op1, op1_enum, count1);
		428	}
		429	}
		430	#endif
		431
		432	if (!ctx->Driver.ProgramStringNotify(ctx, GL_FRAGMENT_SHADER_ATI, NULL)) {
		433	ctx->ATIFragmentShader.Current->isValid = GL_FALSE;
		434	/* XXX is this the right error? */
		435	_mesa_error(ctx, GL_INVALID_OPERATION,
		436	"glEndFragmentShaderATI(driver rejected shader)");
		437	}
		438	}
		439
		440	void GLAPIENTRY
		441	_mesa_PassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)
		442	{
		443	GET_CURRENT_CONTEXT(ctx);
		444	struct ati_fragment_shader *curProg = ctx->ATIFragmentShader.Current;
		445	struct atifs_setupinst *curI;
		446
		447	if (!ctx->ATIFragmentShader.Compiling) {
		448	_mesa_error(ctx, GL_INVALID_OPERATION, "glPassTexCoordATI(outsideShader)");
		449	return;
		450	}
		451
		452	if (curProg->cur_pass == 1) {
		453	match_pair_inst(curProg, 0);
		454	curProg->cur_pass = 2;
		455	}
		456	if ((curProg->cur_pass > 2) \|\|
		457	((1 << (dst - GL_REG_0_ATI)) & curProg->regsAssigned[curProg->cur_pass >> 1])) {
		458	_mesa_error(ctx, GL_INVALID_OPERATION, "glPassTexCoord(pass)");
		459	return;
		460	}
		461	if ((dst < GL_REG_0_ATI) \|\| (dst > GL_REG_5_ATI) \|\|
		462	((dst - GL_REG_0_ATI) >= ctx->Const.MaxTextureUnits)) {
		463	_mesa_error(ctx, GL_INVALID_ENUM, "glPassTexCoordATI(dst)");
		464	return;
		465	}
		466	if (((coord < GL_REG_0_ATI) \|\| (coord > GL_REG_5_ATI)) &&
		467	((coord < GL_TEXTURE0_ARB) \|\| (coord > GL_TEXTURE7_ARB) \|\|
		468	((coord - GL_TEXTURE0_ARB) >= ctx->Const.MaxTextureUnits))) {
		469	_mesa_error(ctx, GL_INVALID_ENUM, "glPassTexCoordATI(coord)");
		470	return;
		471	}
		472	if ((curProg->cur_pass == 0) && (coord >= GL_REG_0_ATI)) {
		473	_mesa_error(ctx, GL_INVALID_OPERATION, "glPassTexCoordATI(coord)");
		474	return;
		475	}
		476	if (!(swizzle >= GL_SWIZZLE_STR_ATI) && (swizzle <= GL_SWIZZLE_STQ_DQ_ATI)) {
		477	_mesa_error(ctx, GL_INVALID_ENUM, "glPassTexCoordATI(swizzle)");
		478	return;
		479	}
		480	if ((swizzle & 1) && (coord >= GL_REG_0_ATI)) {
		481	_mesa_error(ctx, GL_INVALID_OPERATION, "glPassTexCoordATI(swizzle)");
		482	return;
		483	}
		484	if (coord <= GL_TEXTURE7_ARB) {
		485	GLuint tmp = coord - GL_TEXTURE0_ARB;
		486	if ((((curProg->swizzlerq >> (tmp * 2)) & 3) != 0) &&
		487	(((swizzle & 1) + 1) != ((curProg->swizzlerq >> (tmp * 2)) & 3))) {
		488	_mesa_error(ctx, GL_INVALID_OPERATION, "glPassTexCoordATI(swizzle)");
		489	return;
		490	} else {
		491	curProg->swizzlerq \|= (((swizzle & 1) + 1) << (tmp * 2));
		492	}
		493	}
		494
		495	curProg->regsAssigned[curProg->cur_pass >> 1] \|= 1 << (dst - GL_REG_0_ATI);
		496	new_tex_inst(curProg);
		497
		498	/* add the instructions */
		499	curI = &curProg->SetupInst[curProg->cur_pass >> 1][dst - GL_REG_0_ATI];
		500
		501	curI->Opcode = ATI_FRAGMENT_SHADER_PASS_OP;
		502	curI->src = coord;
		503	curI->swizzle = swizzle;
		504
		505	#if MESA_DEBUG_ATI_FS
		506	_mesa_debug(ctx, "%s(%s, %s, %s)\n", __FUNCTION__,
		507	_mesa_lookup_enum_by_nr(dst), _mesa_lookup_enum_by_nr(coord),
		508	_mesa_lookup_enum_by_nr(swizzle));
		509	#endif
		510	}
		511
		512	void GLAPIENTRY
		513	_mesa_SampleMapATI(GLuint dst, GLuint interp, GLenum swizzle)
		514	{
		515	GET_CURRENT_CONTEXT(ctx);
		516	struct ati_fragment_shader *curProg = ctx->ATIFragmentShader.Current;
		517	struct atifs_setupinst *curI;
		518
		519	if (!ctx->ATIFragmentShader.Compiling) {
		520	_mesa_error(ctx, GL_INVALID_OPERATION, "glSampleMapATI(outsideShader)");
		521	return;
		522	}
		523
		524	if (curProg->cur_pass == 1) {
		525	match_pair_inst(curProg, 0);
		526	curProg->cur_pass = 2;
		527	}
		528	if ((curProg->cur_pass > 2) \|\|
		529	((1 << (dst - GL_REG_0_ATI)) & curProg->regsAssigned[curProg->cur_pass >> 1])) {
		530	_mesa_error(ctx, GL_INVALID_OPERATION, "glSampleMapATI(pass)");
		531	return;
		532	}
		533	if ((dst < GL_REG_0_ATI) \|\| (dst > GL_REG_5_ATI) \|\|
		534	((dst - GL_REG_0_ATI) >= ctx->Const.MaxTextureUnits)) {
		535	_mesa_error(ctx, GL_INVALID_ENUM, "glSampleMapATI(dst)");
		536	return;
		537	}
		538	if (((interp < GL_REG_0_ATI) \|\| (interp > GL_REG_5_ATI)) &&
		539	((interp < GL_TEXTURE0_ARB) \|\| (interp > GL_TEXTURE7_ARB) \|\|
		540	((interp - GL_TEXTURE0_ARB) >= ctx->Const.MaxTextureUnits))) {
		541	/* is this texture5 or texture7? spec is a bit unclear there */
		542	_mesa_error(ctx, GL_INVALID_ENUM, "glSampleMapATI(interp)");
		543	return;
		544	}
		545	if ((curProg->cur_pass == 0) && (interp >= GL_REG_0_ATI)) {
		546	_mesa_error(ctx, GL_INVALID_OPERATION, "glSampleMapATI(interp)");
		547	return;
		548	}
		549	if (!(swizzle >= GL_SWIZZLE_STR_ATI) && (swizzle <= GL_SWIZZLE_STQ_DQ_ATI)) {
		550	_mesa_error(ctx, GL_INVALID_ENUM, "glSampleMapATI(swizzle)");
		551	return;
		552	}
		553	if ((swizzle & 1) && (interp >= GL_REG_0_ATI)) {
		554	_mesa_error(ctx, GL_INVALID_OPERATION, "glSampleMapATI(swizzle)");
		555	return;
		556	}
		557	if (interp <= GL_TEXTURE7_ARB) {
		558	GLuint tmp = interp - GL_TEXTURE0_ARB;
		559	if ((((curProg->swizzlerq >> (tmp * 2)) & 3) != 0) &&
		560	(((swizzle & 1) + 1) != ((curProg->swizzlerq >> (tmp * 2)) & 3))) {
		561	_mesa_error(ctx, GL_INVALID_OPERATION, "glSampleMapATI(swizzle)");
		562	return;
		563	} else {
		564	curProg->swizzlerq \|= (((swizzle & 1) + 1) << (tmp * 2));
		565	}
		566	}
		567
		568	curProg->regsAssigned[curProg->cur_pass >> 1] \|= 1 << (dst - GL_REG_0_ATI);
		569	new_tex_inst(curProg);
		570
		571	/* add the instructions */
		572	curI = &curProg->SetupInst[curProg->cur_pass >> 1][dst - GL_REG_0_ATI];
		573
		574	curI->Opcode = ATI_FRAGMENT_SHADER_SAMPLE_OP;
		575	curI->src = interp;
		576	curI->swizzle = swizzle;
		577
		578	#if MESA_DEBUG_ATI_FS
		579	_mesa_debug(ctx, "%s(%s, %s, %s)\n", __FUNCTION__,
		580	_mesa_lookup_enum_by_nr(dst), _mesa_lookup_enum_by_nr(interp),
		581	_mesa_lookup_enum_by_nr(swizzle));
		582	#endif
		583	}
		584
		585	static void
		586	_mesa_FragmentOpXATI(GLint optype, GLuint arg_count, GLenum op, GLuint dst,
		587	GLuint dstMask, GLuint dstMod, GLuint arg1,
		588	GLuint arg1Rep, GLuint arg1Mod, GLuint arg2,
		589	GLuint arg2Rep, GLuint arg2Mod, GLuint arg3,
		590	GLuint arg3Rep, GLuint arg3Mod)
		591	{
		592	GET_CURRENT_CONTEXT(ctx);
		593	struct ati_fragment_shader *curProg = ctx->ATIFragmentShader.Current;
		594	GLint ci;
		595	struct atifs_instruction *curI;
		596	GLuint modtemp = dstMod & ~GL_SATURATE_BIT_ATI;
		597
		598	if (!ctx->ATIFragmentShader.Compiling) {
		599	_mesa_error(ctx, GL_INVALID_OPERATION, "C/AFragmentOpATI(outsideShader)");
		600	return;
		601	}
		602
		603	if (curProg->cur_pass==0)
		604	curProg->cur_pass=1;
		605
		606	else if (curProg->cur_pass==2)
		607	curProg->cur_pass=3;
		608
		609	/* decide whether this is a new instruction or not ... all color instructions are new,
		610	and alpha instructions might also be new if there was no preceding color inst */
		611	if ((optype == 0) \|\| (curProg->last_optype == optype)) {
		612	if (curProg->numArithInstr[curProg->cur_pass >> 1] > 7) {
		613	_mesa_error(ctx, GL_INVALID_OPERATION, "C/AFragmentOpATI(instrCount)");
		614	return;
		615	}
		616	/* easier to do that here slight side effect invalid instr will still be inserted as nops */
		617	match_pair_inst(curProg, optype);
		618	new_arith_inst(curProg);
		619	}
		620	curProg->last_optype = optype;
		621	ci = curProg->numArithInstr[curProg->cur_pass >> 1] - 1;
		622
		623	/* add the instructions */
		624	curI = &curProg->Instructions[curProg->cur_pass >> 1][ci];
		625
		626	/* error checking */
		627	if ((dst < GL_REG_0_ATI) \|\| (dst > GL_REG_5_ATI)) {
		628	_mesa_error(ctx, GL_INVALID_ENUM, "C/AFragmentOpATI(dst)");
		629	return;
		630	}
		631	if ((modtemp != GL_NONE) && (modtemp != GL_2X_BIT_ATI) &&
		632	(modtemp != GL_4X_BIT_ATI) && (modtemp != GL_8X_BIT_ATI) &&
		633	(modtemp != GL_HALF_BIT_ATI) && !(modtemp != GL_QUARTER_BIT_ATI) &&
		634	(modtemp != GL_EIGHTH_BIT_ATI)) {
		635	_mesa_error(ctx, GL_INVALID_ENUM, "C/AFragmentOpATI(dstMod)%x", modtemp);
		636	return;
		637	}
		638	/* op checking? Actually looks like that's missing in the spec but we'll do it anyway */
		639	if (((op < GL_ADD_ATI) \|\| (op > GL_DOT2_ADD_ATI)) && !(op == GL_MOV_ATI)) {
		640	_mesa_error(ctx, GL_INVALID_ENUM, "C/AFragmentOpATI(op)");
		641	return;
		642	}
		643	if (optype == 1) {
		644	if (((op == GL_DOT2_ADD_ATI) && (curI->Opcode[0] != GL_DOT2_ADD_ATI)) \|\|
		645	((op == GL_DOT3_ATI) && (curI->Opcode[0] != GL_DOT3_ATI)) \|\|
		646	((op == GL_DOT4_ATI) && (curI->Opcode[0] != GL_DOT4_ATI)) \|\|
		647	((op != GL_DOT4_ATI) && (curI->Opcode[0] == GL_DOT4_ATI))) {
		648	_mesa_error(ctx, GL_INVALID_OPERATION, "AFragmentOpATI(op)");
		649	return;
		650	}
		651	}
		652	if ((op == GL_DOT4_ATI) &&
		653	(((arg1 == GL_SECONDARY_INTERPOLATOR_ATI) && ((arg1Rep == GL_ALPHA) \|\| (arg1Rep == GL_NONE))) \|\|
		654	(((arg2 == GL_SECONDARY_INTERPOLATOR_ATI) && ((arg2Rep == GL_ALPHA) \|\| (arg2Rep == GL_NONE)))))) {
		655	_mesa_error(ctx, GL_INVALID_OPERATION, "C/AFragmentOpATI(sec_interp)");
		656	}
		657
		658	if (!check_arith_arg(curProg, optype, arg1, arg1Rep)) {
		659	return;
		660	}
		661	if (arg2) {
		662	if (!check_arith_arg(curProg, optype, arg2, arg2Rep)) {
		663	return;
		664	}
		665	}
		666	if (arg3) {
		667	if (!check_arith_arg(curProg, optype, arg3, arg3Rep)) {
		668	return;
		669	}
		670	if ((arg1 >= GL_CON_0_ATI) && (arg1 <= GL_CON_7_ATI) &&
		671	(arg2 >= GL_CON_0_ATI) && (arg2 <= GL_CON_7_ATI) &&
		672	(arg3 >= GL_CON_0_ATI) && (arg3 <= GL_CON_7_ATI) &&
		673	(arg1 != arg2) && (arg1 != arg3) && (arg2 != arg3)) {
		674	_mesa_error(ctx, GL_INVALID_OPERATION, "C/AFragmentOpATI(3Consts)");
		675	return;
		676	}
		677	}
		678
		679	/* all ok - not all fully validated though (e.g. argNMod - spec doesn't say anything) */
		680
		681	curI->Opcode[optype] = op;
		682	curI->SrcReg[optype][0].Index = arg1;
		683	curI->SrcReg[optype][0].argRep = arg1Rep;
		684	curI->SrcReg[optype][0].argMod = arg1Mod;
		685	curI->ArgCount[optype] = arg_count;
		686
		687	if (arg2) {
		688	curI->SrcReg[optype][1].Index = arg2;
		689	curI->SrcReg[optype][1].argRep = arg2Rep;
		690	curI->SrcReg[optype][1].argMod = arg2Mod;
		691	}
		692
		693	if (arg3) {
		694	curI->SrcReg[optype][2].Index = arg3;
		695	curI->SrcReg[optype][2].argRep = arg3Rep;
		696	curI->SrcReg[optype][2].argMod = arg3Mod;
		697	}
		698
		699	curI->DstReg[optype].Index = dst;
		700	curI->DstReg[optype].dstMod = dstMod;
		701	curI->DstReg[optype].dstMask = dstMask;
		702
		703	#if MESA_DEBUG_ATI_FS
		704	debug_op(optype, arg_count, op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
		705	#endif
		706
		707	}
		708
		709	void GLAPIENTRY
		710	_mesa_ColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask,
		711	GLuint dstMod, GLuint arg1, GLuint arg1Rep,
		712	GLuint arg1Mod)
		713	{
		714	_mesa_FragmentOpXATI(ATI_FRAGMENT_SHADER_COLOR_OP, 1, op, dst, dstMask,
		715	dstMod, arg1, arg1Rep, arg1Mod, 0, 0, 0, 0, 0, 0);
		716	}
		717
		718	void GLAPIENTRY
		719	_mesa_ColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask,
		720	GLuint dstMod, GLuint arg1, GLuint arg1Rep,
		721	GLuint arg1Mod, GLuint arg2, GLuint arg2Rep,
		722	GLuint arg2Mod)
		723	{
		724	_mesa_FragmentOpXATI(ATI_FRAGMENT_SHADER_COLOR_OP, 2, op, dst, dstMask,
		725	dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep,
		726	arg2Mod, 0, 0, 0);
		727	}
		728
		729	void GLAPIENTRY
		730	_mesa_ColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask,
		731	GLuint dstMod, GLuint arg1, GLuint arg1Rep,
		732	GLuint arg1Mod, GLuint arg2, GLuint arg2Rep,
		733	GLuint arg2Mod, GLuint arg3, GLuint arg3Rep,
		734	GLuint arg3Mod)
		735	{
		736	_mesa_FragmentOpXATI(ATI_FRAGMENT_SHADER_COLOR_OP, 3, op, dst, dstMask,
		737	dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep,
		738	arg2Mod, arg3, arg3Rep, arg3Mod);
		739	}
		740
		741	void GLAPIENTRY
		742	_mesa_AlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1,
		743	GLuint arg1Rep, GLuint arg1Mod)
		744	{
		745	_mesa_FragmentOpXATI(ATI_FRAGMENT_SHADER_ALPHA_OP, 1, op, dst, 0, dstMod,
		746	arg1, arg1Rep, arg1Mod, 0, 0, 0, 0, 0, 0);
		747	}
		748
		749	void GLAPIENTRY
		750	_mesa_AlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1,
		751	GLuint arg1Rep, GLuint arg1Mod, GLuint arg2,
		752	GLuint arg2Rep, GLuint arg2Mod)
		753	{
		754	_mesa_FragmentOpXATI(ATI_FRAGMENT_SHADER_ALPHA_OP, 2, op, dst, 0, dstMod,
		755	arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, 0, 0,
		756	0);
		757	}
		758
		759	void GLAPIENTRY
		760	_mesa_AlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1,
		761	GLuint arg1Rep, GLuint arg1Mod, GLuint arg2,
		762	GLuint arg2Rep, GLuint arg2Mod, GLuint arg3,
		763	GLuint arg3Rep, GLuint arg3Mod)
		764	{
		765	_mesa_FragmentOpXATI(ATI_FRAGMENT_SHADER_ALPHA_OP, 3, op, dst, 0, dstMod,
		766	arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3,
		767	arg3Rep, arg3Mod);
		768	}
		769
		770	void GLAPIENTRY
		771	_mesa_SetFragmentShaderConstantATI(GLuint dst, const GLfloat * value)
		772	{
		773	GLuint dstindex;
		774	GET_CURRENT_CONTEXT(ctx);
		775
		776	if ((dst < GL_CON_0_ATI) \|\| (dst > GL_CON_7_ATI)) {
		777	/* spec says nothing about what should happen here but we can't just segfault...*/
		778	_mesa_error(ctx, GL_INVALID_ENUM, "glSetFragmentShaderConstantATI(dst)");
		779	return;
		780	}
		781
		782	dstindex = dst - GL_CON_0_ATI;
		783	if (ctx->ATIFragmentShader.Compiling) {
		784	struct ati_fragment_shader *curProg = ctx->ATIFragmentShader.Current;
		785	COPY_4V(curProg->Constants[dstindex], value);
		786	curProg->LocalConstDef \|= 1 << dstindex;
		787	}
		788	else {
		789	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		790	COPY_4V(ctx->ATIFragmentShader.GlobalConstants[dstindex], value);
		791	}
		792	}
		793
		794	#endif /* FEATURE_ATI_fragment_shader */

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/mesa/main/atifragshader.c – Rev 3922