Home www

3DOT Art digital gallery

Stručná charakteristika projektu 3DOT engine

Cílem projektu je vyvinout software, pracující se základními OpenGl objekty

v 3D prostoru , které mohou měnit své parametry, dynamicky, během online

renderování a to na základě dat přicházejících za pomocí různých interfejsů

z reálného světa a zpracovaných pomocí skriptovacích či jiných technik,

použitých v tomto engine nebo i mimo něj.

Projekt si neklade za cíl modelování k tomu jsou určeny jiné 3D programy, ze

kterými jej nelze srovnávat i když některé modelovací možnosti snad bude

mít ale spíše jen jako výsledek po zpracování dat.

Pokud je nutné použít složitější 3D tvary , je potřeba je vymodelovat v

příslušném 3D software a exportovat do obj, který tento engine je schopen

importovat

3DOT engine je výchozím prostředkem pro projekty :

3D Vizualizací

ViDJ

...

2.10.2005 Vertex Fragment shader, GLSL

Zavedení možnosti programování shaderů na grafické kartě (zatím testováno na ATI Mobility Radeon 9700) přináší další neskutečné možnosti 3DOT enginu . Pro prvotní experimenty jsem zavedl jeden společný GLSL program pro všechny objekty, respektivě zatím jen obj objekty.

obrázek znázorňuje dynamicky měněné parametry fragment shaderu, jen pro jeden obj

Algoritmus zpracovávání bude následující. Shadery se budou dělit na statické a pomalejší dynamické. Statické se nahrajou před renderováním scény, konkrétněji při startu aplikace. Ve stromu se pak objeví stejně, jako když se přidávají primitivy nebo obj. Každý shader pak bude mít x počet parametrů typu program.local ,které se budou moci během renderování dynamicky měnit a to i pomocí VB skriptu. Dynamické shadery budou obdobné, jen s tím rozdílem, že se nebudou nahrávat do grafické karty ale zůstanou v paměti počítače jako zdrojový kód a do grafiky se nahrají když bude potřeba, případně se přehraje v grafice starý za nový s jinými parametry. Tím se dosáhne různých efektů ale renderování se zpomalí, u některých aplikací to ovšem nemusí být na závadu.

Algoritmus vykreslování je následující, prozatím pro účely hraní si se shadery používám jen jeden pro všechno :

2. Každý objekt se skládá z množiny primitiv, před jejim vykreslování se povolí daný vertex,fragment shader pomocí glEnable( ... )

	if( glSupportVersion==ATI_SUPPVERS )
	{
		if( vShad && ReCompileEnable )
		{
			glEnable( GL_VERTEX_PROGRAM_ARB);
			glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB,0	,paramX,...		}
		if( fShad && ReCompileEnable )
		{
			glEnable( GL_FRAGMENT_PROGRAM_ARB);
			glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,0	,paramX,...		}

!!ARBfp1.0

#phong lighting shader

TEMP tmp;
TEMP dif;
TEMP spec;
TEMP view;

ATTRIB tex = fragment.texcoord[0];
ATTRIB nrm = fragment.texcoord[1];
ATTRIB lVec = fragment.texcoord[2];
ATTRIB vDir = fragment.texcoord[3];

PARAM color = program.local[0];
PARAM const = {0.2, 0.2, 0.2, 32.0};

OUTPUT out = result.color;

#Normalize the normal
DP3 tmp.a, nrm, nrm;
RSQ tmp.a, tmp.a;
MUL tmp.rgb, nrm, tmp.a;

#normalize the view direction
DP3 view.a, vDir, vDir;
RSQ view.a, view.a;
MUL view.rgb, vDir, view.a;

#compute half angle vector
ADD spec.rgb, view, lVec;
DP3 spec.a, spec, spec;
RSQ spec.a, spec.a;
MUL spec.rgb, spec, spec.a;

#compute specular intensisty
DP3_SAT spec.a, spec, tmp;
LG2 spec.a, spec.a;
MUL spec.a, spec.a, const.w;
EX2 spec.a, spec.a;

#compute diffuse illum
DP3_SAT dif, tmp, lVec;
ADD_SAT dif.rgb, dif, const;

#sum
MAD_SAT dif.rgb, color, dif, spec.a;
MOV dif.a, color.a;

MOV out, dif;

END

!!ARBvp1.0

#Declarations
ATTRIB in = vertex.position;
ATTRIB nrm = vertex.normal;
ATTRIB tex = vertex.texcoord[0];

PARAM mvp[4] = { state.matrix.mvp };
PARAM mv[4] = { state.matrix.modelview };
PARAM light = program.local[0];

PARAM const = {0.0, 0.0, 0.0, 0.2};

OUTPUT out = result.position;
OUTPUT oTex = result.texcoord[0];
OUTPUT oNrm = result.texcoord[1];
OUTPUT lVec = result.texcoord[2];
OUTPUT vDir = result.texcoord[3];

TEMP tmp;

#transform the positions
DP4 out.x, in, mvp[0];
DP4 out.y, in, mvp[1];
DP4 out.z, in, mvp[2];
DP4 out.w, in, mvp[3];

#transform the position to eye-space
DP4 tmp.x, in, mv[0];
DP4 tmp.y, in, mv[1];
DP4 tmp.z, in, mv[2];
DP4 tmp.w, in, mv[3];

#view direction
MOV vDir, -tmp;

#transfrom the normal to eye-space
DP3 oNrm.x, mv[0], nrm;
DP3 oNrm.y, mv[1], nrm;
DP3 oNrm.z, mv[2], nrm;

#output the light vector
MOV lVec, light;

#output the texcoords
MOV oTex, tex;

END

Home www.visualprog.cz

3D OpenGl Technology Engine 2

2.10.2005 Vertex Fragment shader, GLSL