Navigation

← Previous Changeset
Next Changeset →

Changeset 516

Timestamp:

03/22/08 20:01:00 (5 months ago)

Author:

krobillard

Message:

Thune version bumped to 0.0.4.
Added RPM spec file. Now builds on openSUSE Build Service.
GL - Added quad-skin. Text now accepts /center and /right selector.

Files:

trunk/thune/CMakeLists.txt (modified) (1 diff)
trunk/thune/LICENSE (added)
trunk/thune/boot.c (modified) (1 diff)
trunk/thune/doc/GLManual (modified) (5 diffs)
trunk/thune/eval.c (modified) (5 diffs)
trunk/thune/gl/boot.c (modified) (3 diffs)
trunk/thune/gl/draw_list.c (modified) (28 diffs)
trunk/thune/gl/draw_ops.h (modified) (1 diff)
trunk/thune/gl/gx.c (modified) (3 diffs)
trunk/thune/gl/gx.h (modified) (2 diffs)
trunk/thune/gl/gx.t (modified) (2 diffs)
trunk/thune/gl/gx_atoms.h (modified) (1 diff)
trunk/thune/gl/gx_dt.c (modified) (1 diff)
trunk/thune/gl/shader.c (modified) (3 diffs)
trunk/thune/gl/shader.h (modified) (2 diffs)
trunk/thune/internal.h (modified) (1 diff)
trunk/thune/make.c (modified) (1 diff)
trunk/thune/mkboot.t (modified) (1 diff)
trunk/thune/print.c (modified) (2 diffs)
trunk/thune/project.r (modified) (1 diff)
trunk/thune/thune.spec (added)
trunk/thune/urlan.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/thune/CMakeLists.txt

r514 r516

1 project( ~~Thune~~ )
1 project(Thune C)
2 2
3 3 # set(CMAKE_BUILD_TYPE Debug)

trunk/thune/boot.c

r512	r516
105	105	"proc :parse.some ;(data rules -- )\n"
106	106	"[\n"
107		" 0,0,3 :version\n"
	107	" 0,0,4 :version\n"
108	108	" none :os\n"
109	109	" [] :devices\n"

trunk/thune/doc/GLManual

r458	r516
13	13	Thune-GL expands Thune with datatypes, functions and dialects for using
14	14	OpenGL and OpenAL.
	15
	16
	17	About This Document
	18	-------------------
	19
	20	This manual is largely incomplete.
	21
15	22
16	23
…	…
223	230	nop No operation
224	231	clear glClear()
225		call draw-list
	232	call draw-list glCallList() or evaluate draw-list
226	233	enable/F glEnable()
227	234	disable/F glDisable()
…	…
229	236	model Draw with texture (will be changed)
230	237	decal texture Bind Texture with transparency
231		particle 'off/'add/'burn/'trans Set blending for drawing particles
	238	particle/M 'off/'add/'burn/'trans Set blending for drawing particles
232	239	camera camera-context Set GL viewport and matricies
	240	image_ [x,y] texture Draw textured quad
233	241	light logic!/vec3!/block!
234	242	light/N logic!/vec3!/block!
…	…
240	248	rotate angle axis glRotatef()
241	249	scale vec3!/number! glScalef()
242		font font! ~~Draw with font~~
	250	font font! Set font used by text instruction
243	251	text [coord!] text Draw text in current font
244	252	sphere radius slices,stacks Draw textured GLUT sphere
245	253	shader shader!/none!/0 Load shader
246	254	framebuffer framebuffer!/none!/0 Bind framebuffer
	255	samples-query draw-list process Sample draw-list and process results
	256	samples-begin glBeginQuery()
247	257	shadow-begin framebuffer!
248	258	shadow-end
249	259	================ ====================== ======================
	260
	261
	262	Image
	263	+++++
	264	::
	265
	266	image[/trans] [x,y] texture
	267
	268	Draw a 2D image.
	269
	270	The position of the bottom-left corner may be specified with a coord! or vec3!.
	271
	272	Use the /trans selector to enable transparency.
250	273
251	274
…	…
363	386	1 5 4 3 5 5 2 5 7 0 5 6 ; -Z
364	387	]
365

trunk/thune/eval.c

r512	r516
167	167	if( ur_type(val) >= UT_BI_COUNT )
168	168	{
169		UDatatypeSelFunc func = ut->env->customDT
170		[ ur_type(val) - UT_BI_COUNT ].selectAtom;
	169	UDatatypeSelFunc func = CUSTOM_DT(ur_type(val)).selectAtom;
171	170	if( func )
172	171	return func( ut, val, sel, res );
…	…
816	815	if( ur_type(a) >= UT_BI_COUNT )
817	816	{
818		UDatatypeCmpFunc func = ut->env->customDT
819		[ ur_type(a) - UT_BI_COUNT ].compare;
	817	UDatatypeCmpFunc func = CUSTOM_DT( ur_type(a) ).compare;
820	818	return func( ut, a, b, 1 );
821	819	}
…	…
1093	1091	return;
1094	1092	}
1095
1096		if( ur_is(tos, UT_CONTEXT) )
	1093	else if( ur_is(tos, UT_CONTEXT) )
1097	1094	{
1098	1095	val = ur_s_prev( tos );
…	…
1121	1118	}
1122	1119	}
	1120	#if 0
	1121	else if( ur_type(tos) >= UT_BI_COUNT )
	1122	{
	1123	val = ur_s_prev( tos );
	1124	if( ur_isAWord(val) )
	1125	{
	1126	UDatatypeSelFunc func = CUSTOM_DT( ur_type(tos) ).selectAtom;
	1127	if( func )
	1128	{
	1129	UCell sel;
	1130	sel.word.flags = UR_FLAG_SEL_ATOM;
	1131	ur_sel(&sel) = ur_atom(val);
	1132	if( func( ut, tos, &sel, val ) )
	1133	{
	1134	UR_S_DROP;
	1135	return;
	1136	}
	1137	}
	1138	}
	1139	}
	1140	#endif
1123	1141
1124	1142	ur_throwErr( UR_ERR_DATATYPE, "get expected word!" );
…	…
1324	1342	if( ur_type(val) >= UT_BI_COUNT )
1325	1343	{
1326		UCall func = ~~ut->env->customDT[ ur_type(val) - UT_BI_COUNT ]~~.toType;
	1344	UCall func = CUSTOM_DT( ur_type(val) ).toType;
1327	1345	func( ut, tos );
1328	1346	return;

trunk/thune/gl/boot.c

r499	r516
1	1	"[file string!] [\n"
2	2	" file 16 read\n"
3		" dup ~~{RIFF}~~ match ift (file load-wav return)\n"
	3	" dup \"RIFF\" match ift (file load-wav return)\n"
4	4	" file read\n"
5		" dup ~~{#!}~~ match ift (eol find)\n"
	5	" dup \"#!\" match ift (eol find)\n"
6	6	" to-block kernel-ops infuse\n"
7	7	"] func :load\n"
…	…
108	108	" quad-strip\n"
109	109	" sphere\n"
	110	" quad-skin\n"
110	111	" camera\n"
111	112	" light\n"
…	…
119	120	" text\n"
120	121	" shader\n"
	122	" uniform\n"
121	123	" framebuffer\n"
122	124	" shadow-begin\n"

trunk/thune/gl/draw_list.c

r492	r516
31	31
32	32	extern struct GXEnv gxEnv;
	33
	34
	35	#define COW_VALUE(cell,val) \
	36	if( ur_is(cell, UT_WORD) ) { \
	37	val = ur_wordCell(ut, cell); \
	38	if( ! val ) return 0; \
	39	} \
	40	else val = cell;
33	41
34	42
…	…
64	72
65	73
66		st~~atic struct GrRenderState _s~~tate;
	74	struct GrRenderState grState;
67	75
68	76
…	…
95	103	void gr_clearState()
96	104	{
97		_state.stateId = GRS_UNSET;
98		_state.enableMask = EN_DEFAULT;
99		_state.fontN = 0;
100		_state.penX = 0;
101		_state.penY = 0;
102		_state.vertVals = 0;
103		_state.normVals = 0;
104		_state.uvVals = 0;
105		_state.colorVals = 0;
106		_state.attr[0].vals = 0;
107		_state.attr[1].vals = 0;
108		_state.samplesQueryId = 0;
	105	grState.stateId = GRS_UNSET;
	106	grState.enableMask = EN_DEFAULT;
	107	grState.fontN = 0;
	108	grState.penX = 0;
	109	grState.penY = 0;
	110	grState.vertVals = 0;
	111	grState.normVals = 0;
	112	grState.uvVals = 0;
	113	grState.colorVals = 0;
	114	grState.attr[0].vals = 0;
	115	grState.attr[1].vals = 0;
	116	grState.samplesQueryId = 0;
	117	grState.shaderProg = 0;
109	118	}
110	119
…	…
116	125	void gr_setState( int sid )
117	126	{
118		if( _state.stateId == sid )
	127	if( grState.stateId == sid )
119	128	return;
120	129
…	…
197	206	}
198	207
199		_state.stateId = sid;
	208	grState.stateId = sid;
200	209	}
201	210
…	…
322	331	The pen is moved to the end of text.
323	332	*/
324		void gr_drawText( ~~UThread* ut~~, const char* it, const char* end )
	333	void gr_drawText( TexFont* tf, const char* it, const char* end )
325	334	{
326	335	GLfloat x, y;
327		~~TexFont* tf;~~
328	336	TexGlyphInfo* prev = 0;
329	337
330		if( (it != end) && _state.fontN )
331		{
332		tf = (TexFont*) ur_binPtr(_state.fontN)->ptr.v;
333
334		x = _state.penX;
335		y = _state.penY;
	338	if( (it != end) )
	339	{
	340	x = grState.penX;
	341	y = grState.penY;
336	342
337	343	//glColor3ub( 255, 255, 255 );
…	…
344	350	x = (GLfloat) tf->max_ascent;
345	351	y -= x * 1.5f; // Estimate of line spacing.
346		x = _state.penX;
	352	x = grState.penX;
347	353	prev = 0;
348	354	}
…	…
361	367	glEnd();
362	368
363		_state.penX = x;
364		_state.penY = y;
365		}
366		}
367
368
369		void gr_drawTextCell( UThread* ut, UCell* cell )
370		{
	369	grState.penX = x;
	370	grState.penY = y;
	371	}
	372	}
	373
	374
	375	void gr_drawTextCell( UThread* ut, UCell* cell, UAtom sel, UCell* area )
	376	{
	377	TexFont* tf;
371	378	char* cpA;
372	379	char* cpB;
373	380
374		if( ~~ur_stringSlice( ut, cell, &cpA, &cpB )~~ )
375		{
376		~~gr_drawText( ut, cpA, cpB )~~;
377		}
378		~~else~~
	381	if( ! grState.fontN )
	382	return;
	383	tf = (TexFont*) ur_binPtr(grState.fontN)->ptr.v;
	384
	385	if( ! ur_stringSlice( ut, cell, &cpA, &cpB ) )
379	386	{
380	387	UString* str = ur_threadTmp( ut );
381	388	str->used = 0;
382	389	ur_toStr( cell, str, 0 );
383		gr_drawText( ut, str->ptr.c, str->ptr.c + str->used );
384		}
	390	cpA = str->ptr.c;
	391	cpB = cpA + str->used;
	392	}
	393
	394	if( area )
	395	{
	396	int16_t* rect = area->coord.elem;
	397	int w = gr_textWidth( tf, cpA, cpB );
	398	int h = tf->max_ascent - (tf->max_ascent >> 1);
	399
	400	if( sel == UR_ATOM_CENTER )
	401	{
	402	grState.penX += rect[0] + ((rect[2] - w) >> 1);
	403	grState.penY += rect[1] + ((rect[3] - h) >> 1);
	404	//printf( "KR %d %d\n", rect[3], h );
	405	}
	406	else if( sel == UR_ATOM_RIGHT )
	407	{
	408	grState.penX += rect[0] + rect[2] - w;
	409	grState.penY += rect[1] + ((rect[3] - h) >> 1);
	410	}
	411	}
	412
	413	gr_drawText( tf, cpA, cpB );
385	414	}
386	415
…	…
786	815
787	816	/*
	817	Draw 9 quads with a single triangle strip.
	818	*/
	819	static UCell* dop_quadSkin( UThread* ut, UCell* pc )
	820	{
	821	UCell* ts; // Texture size
	822	UCell* tc; // Texture coordinates (left,bot,right,top,corner-x,corner-y)
	823	UCell* vc; // View coordinates (x,y,width,height)
	824
	825	++pc;
	826	COW_VALUE(pc, ts);
	827	if( ! ur_is(ts, UT_COORD) )
	828	return 0;
	829	++pc;
	830	COW_VALUE(pc, tc);
	831	if( ! ur_is(tc, UT_COORD) )
	832	return 0;
	833	++pc;
	834	COW_VALUE(pc, vc);
	835	if( ! ur_is(vc, UT_COORD) )
	836	return 0;
	837
	838	{
	839	GLint x = vc->coord.elem[0];
	840	GLint y = vc->coord.elem[1];
	841	GLint x2 = x + vc->coord.elem[2];
	842	GLint y2 = y + vc->coord.elem[3];
	843	GLint cx = tc->coord.elem[4];
	844	GLint cy = tc->coord.elem[5];
	845	GLfloat ws = 1.0 / ((GLfloat) ts->coord.elem[0]);
	846	GLfloat hs = 1.0 / ((GLfloat) ts->coord.elem[1]);
	847	GLfloat tx1 = ((GLfloat) tc->coord.elem[0]) * ws;
	848	GLfloat ty1 = 1.0 - ((GLfloat) tc->coord.elem[1]) * hs;
	849	GLfloat tx2 = ((GLfloat) (tc->coord.elem[2] + 1)) * ws;
	850	GLfloat ty2 = 1.0 - ((GLfloat) (tc->coord.elem[3] + 1)) * hs;
	851	GLfloat tcx = ((GLfloat) cx) * ws;
	852	GLfloat tcy = ((GLfloat) cy) * hs;
	853
	854	glBegin( GL_TRIANGLE_STRIP );
	855
	856	#define QS_VERT(tx,ty,x,y) \
	857	glMultiTexCoord2f(GL_TEXTURE0, tx, ty); \
	858	glVertex2i(x, y)
	859
	860	#if 0
	861	QS_VERT( tx1, ty1, x, y );
	862	QS_VERT( tx1, ty2, x, y2 );
	863	QS_VERT( tx2, ty1, x2, y );
	864	QS_VERT( tx2, ty2, x2, y2 );
	865	#else
	866	/*
	867	15\ 17\ 19\ 21
	868	- \16 \18 \20
	869
	870	14 /12 /10 / 8
	871	13/ 11/ 9/ -
	872
	873	1\ 3\ 5\ 7
	874	0 \ 2 \ 4 \ 6
	875	*/
	876
	877	QS_VERT( tx1, ty1, x, y );
	878	QS_VERT( tx1, ty1 - tcy, x, y + cy );
	879	QS_VERT( tx1 + tcx, ty1, x + cx, y );
	880	QS_VERT( tx1 + tcx, ty1 - tcy, x + cx, y + cy );
	881	QS_VERT( tx2 - tcx, ty1, x2 - cx, y );
	882	QS_VERT( tx2 - tcx, ty1 - tcy, x2 - cx, y + cy );
	883	QS_VERT( tx2, ty1, x2, y );
	884	QS_VERT( tx2, ty1 - tcy, x2, y + cy );
	885
	886	QS_VERT( tx2, ty2 + tcy, x2, y2 - cy );
	887	QS_VERT( tx2 - tcx, ty1 - tcy, x2 - cx, y + cy );
	888	QS_VERT( tx2 - tcx, ty2 + tcy, x2 - cx, y2 - cy );
	889	QS_VERT( tx1 + tcx, ty1 - tcy, x + cx, y + cy );
	890	QS_VERT( tx1 + tcx, ty2 + tcy, x + cx, y2 - cy );
	891	QS_VERT( tx1, ty1 - tcy, x, y + cy );
	892	QS_VERT( tx1, ty2 + tcy, x, y2 - cy );
	893
	894	QS_VERT( tx1, ty2, x, y2 );
	895	QS_VERT( tx1 + tcx, ty2 + tcy, x + cx, y2 - cy );
	896	QS_VERT( tx1 + tcx, ty2, x + cx, y2 );
	897	QS_VERT( tx2 - tcx, ty2 + tcy, x2 - cx, y2 - cy );
	898	QS_VERT( tx2 - tcx, ty2, x2 - cx, y2 );
	899	QS_VERT( tx2, ty2 + tcy, x2, y2 - cy );
	900	QS_VERT( tx2, ty2, x2, y2 );
	901	#endif
	902
	903	glEnd();
	904	}
	905	return pc;
	906	}
	907
	908
	909	/*
788	910	attrib/1 shader/my-attrib float-count #[...]
789	911
…	…
795	917	Shader* sh = 0;
796	918
797		attr = _state.attr + ur_sel(pc);
	919	attr = grState.attr + ur_sel(pc);
798	920	++pc;
799	921
…	…
872	994	case 'a':
873	995	{
874		GrVertexAttribute* attr = _state.attr + pa->ai;
	996	GrVertexAttribute* attr = grState.attr + pa->ai;
875	997	++pa->ai;
876	998	switch( attr->count )
…	…
894	1016	case 'c':
895	1017	{
896		UCell* col = _state.colorVals + i;
	1018	UCell* col = grState.colorVals + i;
897	1019	if( ur_is(col, UT_COORD) )
898	1020	{
…	…
909	1031
910	1032	case 'n':
911		//_getVectord( 3, _state.normVals + it 3, vec );
	1033	//_getVectord( 3, grState.normVals + it 3, vec );
912	1034	//glNormal3dv( vec );
913		glNormal3fv( _state.normVals + i * 3 );
	1035	glNormal3fv( grState.normVals + i * 3 );
914	1036	break;
915	1037
916	1038	case 'v':
917		//_getVectord( 3, _state.vertVals + it 3, vec );
	1039	//_getVectord( 3, grState.vertVals + it 3, vec );
918	1040	//glVertex3dv( vec );
919		glVertex3fv( _state.vertVals + i * 3 );
	1041	glVertex3fv( grState.vertVals + i * 3 );
920	1042	break;
921	1043
922	1044	case 't':
923	1045	{
924		float* uv = _state.uvVals + i * 2;
	1046	float* uv = grState.uvVals + i * 2;
925	1047	//glMultiTexCoord2fv( GL_TEXTURE0, uv );
926	1048	glMultiTexCoord2f( GL_TEXTURE0 + pa->ti, uv[0], 1.0f - uv[1] );
…	…
1008	1130	s = glIsEnabled( e ); \
1009	1131	sf = s ? f : 0; \
1010		mf = _state.enableMask & f; \
	1132	mf = grState.enableMask & f; \
1011	1133	if( sf ^ mf ) \
1012	1134	printf( "%d/%d %s\n", s, mf ? 1 : 0, txt );
…	…
1037	1159
1038	1160	#define ENABLE(f,e) \
1039		if( ! (_state.enableMask & f) ) { \
1040		_state.enableMask \|= f; \
	1161	if( ! (grState.enableMask & f) ) { \
	1162	grState.enableMask \|= f; \
1041	1163	glEnable( e ); }
1042	1164
1043	1165	#define DISABLE(f,e) \
1044		if( _state.enableMask & f ) { \
1045		_state.enableMask &= ~f; \
	1166	if( grState.enableMask & f ) { \
	1167	grState.enableMask &= ~f; \
1046	1168	glDisable( e ); }
1047	1169
…	…
1161	1283
1162	1284
1163		#define VAL_WORD_OR_PC \
1164		if( ur_is(pc, UT_WORD) ) { \
1165		val = ur_wordCell( ut, pc ); \
1166		if( ! val ) return 0; \
1167		} \
1168		else val = pc;
	1285	#define VAL_WORD_OR_PC COW_VALUE(pc, val)
1169	1286
1170	1287	/*
…	…
1317	1434	case DOP_SPHERE: // sphere rad silces,stacks
1318	1435	pc = dop_sphere( ut, pc );
	1436	if( ! pc )
	1437	return 0;
	1438	break;
	1439
	1440	case DOP_QUAD_SKIN: // quad-skin tex-size uvs,corner area
	1441	pc = dop_quadSkin( ut, pc );
1319	1442	if( ! pc )
1320	1443	return 0;
…	…
1385	1508	VAL_WORD_OR_PC
1386	1509	if( ur_is(val, UT_BLOCK) )
1387		_state.colorVals = ur_block(val)->ptr.cells;
	1510	grState.colorVals = ur_block(val)->ptr.cells;
1388	1511	break;
1389	1512
…	…
1392	1515	VAL_WORD_OR_PC
1393	1516	if( ur_is(val, UT_VECTOR) )
1394		_state.vertVals = ur_bin(val)->ptr.f;
	1517	grState.vertVals = ur_bin(val)->ptr.f;
1395	1518	break;
1396	1519
…	…
1399	1522	VAL_WORD_OR_PC
1400	1523	if( ur_is(val, UT_VECTOR) )
1401		_state.normVals = ur_bin(val)->ptr.f;
	1524	grState.normVals = ur_bin(val)->ptr.f;
1402	1525	break;
1403	1526
…	…
1406	1529	VAL_WORD_OR_PC
1407	1530	if( ur_is(val, UT_VECTOR) )
1408		_state.uvVals = ur_bin(val)->ptr.f;
	1531	grState.uvVals = ur_bin(val)->ptr.f;
1409	1532	break;
1410	1533
…	…
1424	1547	case DOP_QUAD_STRIP:
1425	1548	pc += 2;
1426		if( ur_is(pc-1, UT_WORD) && _state.vertVals )
	1549	if( ur_is(pc-1, UT_WORD) && grState.vertVals )
1427	1550	{
1428	1551	if( ur_is(pc, UT_VECTOR) && (ur_vectorDT(pc) == UT_INT) )
…	…
1504	1627
1505	1628	case DOP_FONT:
	1629	{
	1630	int sel = ur_sel(pc);
1506	1631	++pc;
1507	1632	VAL_WORD_OR_PC
1508	1633	if( ur_is(val, UT_FONT) )
1509	1634	{
1510		gr_setState( GRS_TEXT );
1511		glBindTexture( GL_TEXTURE_2D, ur_fontTexId(val) );
1512		_state.fontN = ur_fontTF(val);
1513		}
	1635	if( ! sel )
	1636	{
	1637	gr_setState( GRS_TEXT );
	1638	glBindTexture( GL_TEXTURE_2D, ur_fontTexId(val) );
	1639	}
	1640	grState.fontN = ur_fontTF(val);
	1641	}
	1642	}
1514	1643	break;
1515	1644
1516	1645	case DOP_TEXT:
	1646	{
	1647	int sel = ur_sel(pc);
	1648	UCell* area = 0;
	1649
1517	1650	++pc;
1518	1651	VAL_WORD_OR_PC
1519		if( ur_is(val, UT_COORD) )
1520		{
1521		_state.penX = (GLfloat) val->coord.elem[0];
1522		_state.penY = (GLfloat) val->coord.elem[1];
	1652
	1653	if( (sel == UR_ATOM_CENTER) \|\| (sel == UR_ATOM_RIGHT) )
	1654	{
	1655	if( ! ur_is(val, UT_COORD) \|\| (val->coord.len < 4) )
	1656	return 0;
	1657	area = val;
1523	1658	++pc;
1524	1659	VAL_WORD_OR_PC
1525	1660	}
1526		else if( ur_is(val, UT_VEC3) )
1527		{
1528		_state.penX = val->vec3.xyz[0];
1529		_state.penY = val->vec3.xyz[1];
	1661
	1662	if( ur_is(val, UT_COORD) )
	1663	{
	1664	grState.penX = (GLfloat) val->coord.elem[0];
	1665	grState.penY = (GLfloat) val->coord.elem[1];
1530	1666	++pc;
1531	1667	VAL_WORD_OR_PC
1532	1668	}
1533		gr_drawTextCell( ut, val );
	1669	else if( ur_is(val, UT_VEC3) )
	1670	{
	1671	grState.penX = val->vec3.xyz[0];
	1672	grState.penY = val->vec3.xyz[1];
	1673	++pc;
	1674	VAL_WORD_OR_PC
	1675	}
	1676	else if( sel )
	1677	{
	1678	grState.penX = 0;
	1679	grState.penY = 0;
	1680	}
	1681
	1682	gr_drawTextCell( ut, val, sel, area );
	1683	}
1534	1684	break;
1535	1685
…	…
1539	1689	loadShader( ut, val );
1540	1690	break;
1541
	1691	#if 0
	1692	case DOP_UNIFORM:
	1693	{
	1694	int sel = ur_sel(pc);
	1695	++pc;
	1696	VAL_WORD_OR_PC
	1697	setUniform( ut, sel, pc );
	1698	}
	1699	break;
	1700	#endif
1542	1701	case DOP_FRAMEBUFFER:
1543	1702	++pc;
…	…
1564	1723	int hidden = ur_sel(pc); // UR_ATOM_HIDDEN
1565	1724
1566		_state.samplesQueryId = 0;
	1725	grState.samplesQueryId = 0;
1567	1726
1568	1727	if( hidden )
…	…
1589	1748	#endif
1590	1749
1591		if( _state.samplesQueryId )
	1750	if( grState.samplesQueryId )
1592	1751	glEndQuery( GL_SAMPLES_PASSED );
1593	1752
…	…
1606	1765	// Push query results on stack and call process-block.
1607	1766
1608		for( id = 1; id <= _state.samplesQueryId; ++id )
	1767	for( id = 1; id <= grState.samplesQueryId; ++id )
1609	1768	{
1610	1769	glGetQueryObjectuiv( id, GL_QUERY_RESULT, &samples );
…	…
1621	1780	}
1622	1781
1623		_state.samplesQueryId = 0;
	1782	grState.samplesQueryId = 0;
1624	1783	}
1625	1784	break;
1626	1785
1627	1786	case DOP_SAMPLES_BEGIN:
1628		if( _state.samplesQueryId )
	1787	if( grState.samplesQueryId )
1629	1788	glEndQuery( GL_SAMPLES_PASSED );
1630	1789
1631		++_state.samplesQueryId;
1632		glBeginQuery( GL_SAMPLES_PASSED, _state.samplesQueryId );
	1790	++grState.samplesQueryId;
	1791	glBeginQuery( GL_SAMPLES_PASSED, grState.samplesQueryId );
1633	1792	break;
1634	1793

trunk/thune/gl/draw_ops.h

r458	r516
27	27	#define DOP_QUAD_STRIP 24
28	28	#define DOP_SPHERE 25
29		#define DOP_CAMERA 26
30		#define DOP_LIGHT 27
31		#define DOP_LIGHTING 28
32		#define DOP_PUSH 29
33		#define DOP_POP 30
34		#define DOP_TRANSLATE 31
35		#define DOP_ROTATE 32
36		#define DOP_SCALE 33
37		#define DOP_FONT 34
38		#define DOP_TEXT 35
39		#define DOP_SHADER 36
40		#define DOP_FRAMEBUFFER 37
41		#define DOP_SHADOW_BEGIN 38
42		#define DOP_SHADOW_END 39
43		#define DOP_SAMPLES_QUERY 40
44		#define DOP_SAMPLES_BEGIN 41
	29	#define DOP_QUAD_SKIN 26
	30	#define DOP_CAMERA 27
	31	#define DOP_LIGHT 28
	32	#define DOP_LIGHTING 29
	33	#define DOP_PUSH 30
	34	#define DOP_POP 31
	35	#define DOP_TRANSLATE 32
	36	#define DOP_ROTATE 33
	37	#define DOP_SCALE 34
	38	#define DOP_FONT 35
	39	#define DOP_TEXT 36
	40	#define DOP_SHADER 37
	41	#define DOP_UNIFORM 38
	42	#define DOP_FRAMEBUFFER 39
	43	#define DOP_SHADOW_BEGIN 40
	44	#define DOP_SHADOW_END 41
	45	#define DOP_SAMPLES_QUERY 42
	46	#define DOP_SAMPLES_BEGIN 43

trunk/thune/gl/gx.c

r486	r516
1	1	/*============================================================================
2	2	Thune OpenGL Module
3		Copyright (C) 2005-2007 Karl Robillard
	3	Copyright (C) 2005-2008 Karl Robillard
4	4
5	5	This library is free software; you can redistribute it and/or
…	…
1765	1765	FIXED_ATOM( "area", 4, UR_ATOM_AREA )
1766	1766	FIXED_ATOM( "rect", 4, UR_ATOM_RECT )
	1767	FIXED_ATOM( "size", 4, UR_ATOM_SIZE )
1767	1768	FIXED_ATOM( "raster", 6, UR_ATOM_RASTER )
1768	1769	FIXED_ATOM( "texture", 7, UR_ATOM_TEXTURE )
…	…
1787	1788	FIXED_ATOM( "default", 7, UR_ATOM_DEFAULT );
1788	1789	FIXED_ATOM( "wait", 4, UR_ATOM_WAIT );
	1790
	1791	FIXED_ATOM( "left", 4, UR_ATOM_LEFT );
	1792	FIXED_ATOM( "right", 5, UR_ATOM_RIGHT );
	1793	FIXED_ATOM( "center", 6, UR_ATOM_CENTER );
1789	1794
1790	1795	// Textures

trunk/thune/gl/gx.h

r514	r516
141	141	GrVertexAttribute attr[2];
142	142	GLuint samplesQueryId;
	143	GLuint shaderProg;
143	144	};
144	145
…	…
172	173
173	174
	175	extern struct GrRenderState grState;
	176
174	177	//extern struct GXEnv gxEnv;
175		~~//extern const char* orAtomCString( OAtom atom );~~
176	178
177	179	extern int gx_startup( UrlanEnv* );

trunk/thune/gl/gx.t

r499	r516
171	171
172	172	sphere
	173	quad-skin
173	174
174	175	camera
…	…
186	187
187	188	shader
	189	uniform
188	190	framebuffer
189	191	shadow-begin

trunk/thune/gl/gx_atoms.h

r512	r516
6	6	#define UR_ATOM_AREA 330
7	7	#define UR_ATOM_RECT 331
8		#define UR_ATOM_RASTER 332
9		#define UR_ATOM_TEXTURE 333
10		#define UR_ATOM_ELEM 334
	8	#define UR_ATOM_SIZE 332
	9	#define UR_ATOM_RASTER 333
	10	#define UR_ATOM_TEXTURE 334
	11	#define UR_ATOM_ELEM 335
11	12	#define UR_ATOM_CLOSE 187
12		#define UR_ATOM_FOCUS 335
13		#define UR_ATOM_RESIZE 336
14		#define UR_ATOM_KEY_DOWN 337
15		#define UR_ATOM_KEY_UP 338
16		#define UR_ATOM_MOUSE_MOVE 339
17		#define UR_ATOM_MOUSE_UP 340
18		#define UR_ATOM_MOUSE_DOWN 341
19		#define UR_ATOM_MOUSE_WHEEL 342
20		#define UR_ATOM_AMBIENT 343
21		#define UR_ATOM_DIFFUSE 344
22		#define UR_ATOM_SPECULAR 345
23		#define UR_ATOM_POS 346
24		#define UR_ATOM_SHADER 347
25		#define UR_ATOM_VERTEX 348
26		#define UR_ATOM_FRAGMENT 349
27		#define UR_ATOM_DEFAULT 350
	13	#define UR_ATOM_FOCUS 336
	14	#define UR_ATOM_RESIZE 337
	15	#define UR_ATOM_KEY_DOWN 338
	16	#define UR_ATOM_KEY_UP 339
	17	#define UR_ATOM_MOUSE_MOVE 340
	18	#define UR_ATOM_MOUSE_UP 341
	19	#define UR_ATOM_MOUSE_DOWN 342
	20	#define UR_ATOM_MOUSE_WHEEL 343
	21	#define UR_ATOM_AMBIENT 344
	22	#define UR_ATOM_DIFFUSE 345
	23	#define UR_ATOM_SPECULAR 346
	24	#define UR_ATOM_POS 347
	25	#define UR_ATOM_SHADER 348
	26	#define UR_ATOM_VERTEX 349
	27	#define UR_ATOM_FRAGMENT 350
	28	#define UR_ATOM_DEFAULT 351
28	29	#define UR_ATOM_WAIT 138
29		#define UR_ATOM_RGB 351
30		#define UR_ATOM_RGBA 352
31		#define UR_ATOM_DEPTH 353
32		#define UR_ATOM_CLAMP 354
33		#define UR_ATOM_REPEAT 355
34		#define UR_ATOM_NEAREST 356
35		#define UR_ATOM_LINEAR 357
36		#define UR_ATOM_MIN 358
37		#define UR_ATOM_MAG 359
38		#define UR_ATOM_MIPMAP 360
39		#define UR_ATOM_GRAY 361
40		#define UR_ATOM_RGB 351
41		#define UR_ATOM_RGBA 352
	30	#define UR_ATOM_LEFT 352
	31	#define UR_ATOM_RIGHT 353
	32	#define UR_ATOM_CENTER 354
	33	#define UR_ATOM_RGB 355
	34	#define UR_ATOM_RGBA 356
	35	#define UR_ATOM_DEPTH 357
	36	#define UR_ATOM_CLAMP 358
	37	#define UR_ATOM_REPEAT 359
	38	#define UR_ATOM_NEAREST 360
	39	#define UR_ATOM_LINEAR 361
	40	#define UR_ATOM_MIN 362
	41	#define UR_ATOM_MAG 363
	42	#define UR_ATOM_MIPMAP 364
	43	#define UR_ATOM_GRAY 365
	44	#define UR_ATOM_RGB 355
	45	#define UR_ATOM_RGBA 356
42	46	#define UR_ATOM_ON 271
43	47	#define UR_ATOM_OFF 273
44	48	#define UR_ATOM_ADD 206
45		#define UR_ATOM_BURN 362
46		#define UR_ATOM_COLOR 363
47		#define UR_ATOM_TRANS 364
48		#define UR_ATOM_SPRITE 365
49		#define UR_ATOM_ONCE 366
50		#define UR_ATOM_PING_PONG 367
51		#define UR_ATOM_PONG 368
	49	#define UR_ATOM_BURN 366
	50	#define UR_ATOM_COLOR 367
	51	#define UR_ATOM_TRANS 368
	52	#define UR_ATOM_SPRITE 369
	53	#define UR_ATOM_ONCE 370
	54	#define UR_ATOM_PING_PONG 371
	55	#define UR_ATOM_PONG 372

trunk/thune/gl/gx_dt.c

r512	r516
219	219	ur_initType(res, UT_INT);
220	220	ur_int(res) = rh ? rh->height : 0;
	221	break;
	222
	223	case UR_ATOM_SIZE:
	224	rh = ur_rastHead(val);
	225	ur_initType(res, UT_COORD);
	226	res->coord.len = 2;
	227	if( rh )
	228	{
	229	res->coord.elem[0] = rh->width;
	230	res->coord.elem[1] = rh->height;
	231	}
	232	else
	233	{
	234	res->coord.elem[0] = 0;
	235	res->coord.elem[1] = 0;
	236	}
221	237	break;
222	238	#if 0

trunk/thune/gl/shader.c

r504	r516
1	1	/*============================================================================
2	2	Thune OpenGL Module
3		Copyright (C) 2005-2007 Karl Robillard
	3	Copyright (C) 2005-2008 Karl Robillard
4	4
5	5	This library is free software; you can redistribute it and/or
…	…
290	290	int texUnit = 0;
291	291	Shader* sh = (Shader*) ur_resPtr( cval->series.n )->ptr;
292		glUseProgram( sh->program );
	292	if( grState.shaderProg != sh->program )
	293	{
	294	grState.shaderProg = sh->program;
	295	glUseProgram( sh->program );
	296	}
293	297
294	298	pi = sh->param;
…	…
371	375
372	376
	377

r514	r516
1		project( ~~Thune~~ )
	1	project(Thune C)
2	2
3	3	# set(CMAKE_BUILD_TYPE Debug)