Context Navigation

OgreXSIMaterialExporter.cpp @ 692

Revision 692, 26.7 KB checked in by mattausch, 18 years ago (diff)
adding ogre 1.2 and dependencies

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://www.ogre3d.org/
6
7	Copyright (c) 2000-2005 The OGRE Team
8	Also see acknowledgements in Readme.html
9
10	This program is free software; you can redistribute it and/or modify it under
11	the terms of the GNU Lesser General Public License as published by the Free Software
12	Foundation; either version 2 of the License, or (at your option) any later
13	version.
14
15	This program is distributed in the hope that it will be useful, but WITHOUT
16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19	You should have received a copy of the GNU Lesser General Public License along with
20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22	http://www.gnu.org/copyleft/lesser.txt.
23	-----------------------------------------------------------------------------
24	*/
25	#include "OgreXSIMaterialExporter.h"
26	#include "OgreMaterialManager.h"
27	#include "OgreMaterial.h"
28	#include "OgreTechnique.h"
29	#include "OgrePass.h"
30	#include "OgreTextureUnitState.h"
31
32	#include <xsi_shader.h>
33	#include <xsi_imageclip.h>
34	#include <xsi_image.h>
35
36
37	namespace Ogre {
38
39	//-------------------------------------------------------------------------
40	XsiMaterialExporter::XsiMaterialExporter()
41	{
42
43	}
44	//-------------------------------------------------------------------------
45	XsiMaterialExporter::~XsiMaterialExporter()
46	{
47	clearPassQueue();
48	}
49	//-------------------------------------------------------------------------
50	void XsiMaterialExporter::exportMaterials(MaterialMap& materials,
51	TextureProjectionMap& texProjMap, const String& filename,
52	bool copyTextures)
53	{
54	LogOgreAndXSI(" Begin OGRE Material Export ");
55
56	mTextureProjectionMap = texProjMap;
57
58	String texturePath;
59	if (copyTextures)
60	{
61	// derive the texture path
62	String::size_type pos = filename.find_last_of("\\");
63	if (pos == String::npos)
64	{
65	pos = filename.find_last_of("/");
66	}
67	if (pos != String::npos)
68	{
69	texturePath = filename.substr(0, pos + 1);
70	}
71	}
72
73	mMatSerializer.clearQueue();
74
75	for (MaterialMap::iterator m = materials.begin(); m != materials.end(); ++m)
76	{
77	exportMaterial(m->second, copyTextures, texturePath);
78	}
79
80	mMatSerializer.exportQueued(filename);
81
82	LogOgreAndXSI(" OGRE Material Export Complete ");
83	}
84	//-------------------------------------------------------------------------
85	void XsiMaterialExporter::exportMaterial(MaterialEntry* matEntry,
86	bool copyTextures, const String& texturePath)
87	{
88	LogOgreAndXSI("Exporting " + matEntry->name);
89
90	MaterialPtr mat = MaterialManager::getSingleton().create(
91	matEntry->name,
92	ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
93	Technique* t = mat->createTechnique();
94
95	// collect the passes into our queue
96	// XSI stores passes in reverse order, so invert them
97	clearPassQueue();
98	XSI::Shader shader(matEntry->xsiShader);
99	PassEntry* passEntry = new PassEntry();
100	mPassQueue.push_front(passEntry);
101	while (1)
102	{
103	passEntry->shaders.Add(shader);
104
105	XSI::CRef source = shader.GetParameter(L"previous").GetSource();
106	if(!source.IsValid() \|\| !source.IsA(XSI::siShaderID))
107	{
108	// finish
109	break;
110	}
111
112	shader = XSI::Shader(source);
113	// If we find a 'blending' parameter, we're on a new pass
114	if (shader.GetParameter(L"blending").IsValid())
115	{
116	passEntry = new PassEntry();
117	mPassQueue.push_front(passEntry); // push front to invert order
118	}
119	}
120
121
122	// Now go through each pass and create OGRE version
123	for (PassQueue::iterator p = mPassQueue.begin(); p != mPassQueue.end(); ++p)
124	{
125	PassEntry* passEntry = *p;
126	Pass* pass = t->createPass();
127	LogOgreAndXSI("Added Pass");
128
129	// Need to pre-populate pass textures to match up transforms
130	populatePassTextures(pass, passEntry, copyTextures, texturePath);
131	// Do the rest
132	for (int s = 0; s < passEntry->shaders.GetCount(); ++s)
133	{
134	XSI::Shader shader(passEntry->shaders[s]);
135	populatePass(pass, shader);
136	}
137
138	}
139
140
141	mMatSerializer.queueForExport(mat);
142
143
144	}
145	//-------------------------------------------------------------------------
146	void XsiMaterialExporter::clearPassQueue(void)
147	{
148	for (PassQueue::iterator i = mPassQueue.begin(); i != mPassQueue.end(); ++i)
149	{
150	delete *i;
151	}
152	mPassQueue.clear();
153
154	}
155	//-------------------------------------------------------------------------
156	void XsiMaterialExporter::populatePass(Pass* pass, XSI::Shader& xsishader)
157	{
158	populatePassDepthCull(pass, xsishader);
159	populatePassSceneBlend(pass, xsishader);
160	populatePassLighting(pass, xsishader);
161	populatePassTextureTransforms(pass, xsishader);
162	populatePassCgPrograms(pass, xsishader);
163	populatePassHLSLPrograms(pass, xsishader);
164	populatePassD3DAssemblerPrograms(pass, xsishader);
165	}
166	//-------------------------------------------------------------------------
167	void XsiMaterialExporter::populatePassCgPrograms(Pass* pass,
168	XSI::Shader& xsishader)
169	{
170	XSI::Parameter param = xsishader.GetParameter(L"Cg_Program");
171	if (param.IsValid())
172	{
173	// TODO
174	// XSI can't reference external files which makes it v.difficult to
175	// re-use shaders - mod XSI plugin?
176	}
177	}
178	//-------------------------------------------------------------------------
179	void XsiMaterialExporter::populatePassHLSLPrograms(Pass* pass,
180	XSI::Shader& xsishader)
181	{
182	XSI::Parameter param = xsishader.GetParameter(L"HLSL_Program");
183	if (param.IsValid())
184	{
185	// TODO
186	// XSI can't reference external files which makes it v.difficult to
187	// re-use shaders - mod XSI plugin?
188	}
189	}
190	//-------------------------------------------------------------------------
191	void XsiMaterialExporter::populatePassD3DAssemblerPrograms(Pass* pass,
192	XSI::Shader& xsishader)
193	{
194	XSI::Parameter param = xsishader.GetParameter(L"Vertex_Shader");
195	if (param.IsValid())
196	{
197	// TODO
198	// XSI can't reference external files which makes it v.difficult to
199	// re-use shaders - mod XSI plugin?
200	}
201	param = xsishader.GetParameter(L"Pixel_Shader");
202	if (param.IsValid())
203	{
204	// TODO
205	// XSI can't reference external files which makes it v.difficult to
206	// re-use shaders - mod XSI plugin?
207	}
208	}
209	//-------------------------------------------------------------------------
210	void XsiMaterialExporter::populatePassDepthCull(Pass* pass,
211	XSI::Shader& xsishader)
212	{
213	XSI::Parameter param = xsishader.GetParameter(L"cullingmode");
214	if (param.IsValid())
215	{
216	short xsiCull = param.GetValue();
217	switch (xsiCull)
218	{
219	case 0:
220	pass->setCullingMode(CULL_NONE);
221	pass->setManualCullingMode(MANUAL_CULL_NONE);
222	break;
223	case 1:
224	pass->setCullingMode(CULL_CLOCKWISE);
225	pass->setManualCullingMode(MANUAL_CULL_BACK);
226	break;
227	case 2:
228	pass->setCullingMode(CULL_ANTICLOCKWISE);
229	pass->setManualCullingMode(MANUAL_CULL_FRONT);
230	break;
231
232	};
233	}
234
235	param = xsishader.GetParameter(L"depthtest");
236	if (param.IsValid())
237	{
238	bool depthTest = param.GetValue();
239	pass->setDepthCheckEnabled(depthTest);
240	}
241	param = xsishader.GetParameter(L"depthwrite");
242	if (param.IsValid())
243	{
244	bool depthWrite = param.GetValue();
245	pass->setDepthWriteEnabled(depthWrite);
246	}
247	}
248	//-------------------------------------------------------------------------
249	void XsiMaterialExporter::populatePassSceneBlend(Pass* pass,
250	XSI::Shader& xsishader)
251	{
252	XSI::Parameter param = xsishader.GetParameter(L"blending");
253	if (param.IsValid() && (bool)param.GetValue())
254	{
255	SceneBlendFactor src = SBF_ONE;
256	SceneBlendFactor dst = SBF_ONE;
257
258	param = xsishader.GetParameter(L"srcblendingfunction");
259	if (param.IsValid())
260	{
261	src = convertSceneBlend(param.GetValue());
262	}
263	param = xsishader.GetParameter(L"dstblendingfunction");
264	if (param.IsValid())
265	{
266	dst = convertSceneBlend(param.GetValue());
267	}
268
269	pass->setSceneBlending(src, dst);
270	}
271	}
272	//-------------------------------------------------------------------------
273	void XsiMaterialExporter::populatePassLighting(Pass* pass,
274	XSI::Shader& xsishader)
275	{
276	XSI::Parameter param = xsishader.GetParameter(L"Enable_Lighting");
277	if (param.IsValid())
278	{
279	pass->setLightingEnabled(param.GetValue());
280
281	ColourValue tmpColour;
282	xsishader.GetColorParameterValue(L"Ambient", tmpColour.r, tmpColour.g,
283	tmpColour.b, tmpColour.a);
284	pass->setAmbient(tmpColour);
285	xsishader.GetColorParameterValue(L"Diffuse", tmpColour.r, tmpColour.g,
286	tmpColour.b, tmpColour.a);
287	pass->setDiffuse(tmpColour);
288	xsishader.GetColorParameterValue(L"Emissive", tmpColour.r, tmpColour.g,
289	tmpColour.b, tmpColour.a);
290	pass->setSelfIllumination(tmpColour);
291	xsishader.GetColorParameterValue(L"Specular", tmpColour.r, tmpColour.g,
292	tmpColour.b, tmpColour.a);
293	pass->setSpecular(tmpColour);
294
295	pass->setShininess(xsishader.GetParameter(L"Shininess").GetValue());
296	}
297
298
299	}
300	//-------------------------------------------------------------------------
301	void XsiMaterialExporter::populatePassTextures(Pass* pass,
302	PassEntry* passEntry, bool copyTextures, const String& targetFolder)
303	{
304	// We need to search all shaders back to the point we would change
305	// passes, and add all the textures. This is because we don't know
306	// where in the shaders the texture transforms might be, since they
307	// are linked via 'target' not by being on the same object.
308	mTextureUnitTargetMap.clear();
309
310	for (int s = 0; s < passEntry->shaders.GetCount(); ++s)
311	{
312	XSI::Shader shader(passEntry->shaders[s]);
313	TextureUnitState* tex = 0;
314
315	String progID = XSItoOgre(shader.GetProgID());
316	if (progID.find("OGL13Texture") != String::npos \|\|
317	progID.find("DXTexture") != String::npos \|\|
318	progID.find("OGLCom") != String::npos)
319	{
320	if (!shader.GetParameter(L"bottom").IsValid())
321	{
322	tex = add2DTexture(pass, shader, copyTextures, targetFolder);
323	}
324	else if (shader.GetParameter(L"bottom").IsValid())
325	{
326	tex = addCubicTexture(pass, shader, copyTextures, targetFolder);
327	}
328	}
329	else
330	{
331	continue; // not a texture so skip the rest
332	}
333
334
335	// texture coordinate set
336	XSI::Parameter param = shader.GetParameter(L"tspace_id");
337	if (param.IsValid())
338	{
339	// this is a name, need to look up index
340	tex->setTextureCoordSet(
341	getTextureCoordIndex(XSItoOgre(param.GetValue())));
342	}
343
344	// filtering & anisotropy
345	// DX and GL shaders deal differently
346	if (progID.find("OGL") != String::npos)
347	{
348	populateOGLFiltering(tex, shader);
349	}
350	else if (progID.find("DX") != String::npos)
351	{
352	populateDXFiltering(tex, shader);
353	}
354
355	// colour operation
356	param = shader.GetParameter(L"modulation");
357	if (param.IsValid())
358	{
359	long colourop = param.GetValue();
360	switch (colourop)
361	{
362	case 0:
363	// modulate
364	tex->setColourOperation(LBO_MODULATE);
365	break;
366	case 1:
367	// decal
368	tex->setColourOperation(LBO_ALPHA_BLEND);
369	break;
370	case 2:
371	// blend
372	tex->setColourOperation(LBO_MODULATE);
373	break;
374	case 3:
375	// replace
376	tex->setColourOperation(LBO_REPLACE);
377	break;
378	case 4:
379	// add
380	tex->setColourOperation(LBO_ADD);
381	break;
382	}
383
384	}
385
386
387
388	}
389	}
390	//-------------------------------------------------------------------------
391	TextureUnitState* XsiMaterialExporter::add2DTexture(Pass* pass, XSI::Shader& shader,
392	bool copyTextures, const String& targetFolder)
393	{
394	// create texture unit state and map from target incase future xforms
395	TextureUnitState* tex = pass->createTextureUnitState();
396
397	XSI::Parameter param = shader.GetParameter(L"target"); // OGL
398	if (!param.IsValid())
399	param = shader.GetParameter(L"Texture_Target"); // DX
400
401	long target = param.GetValue();
402	mTextureUnitTargetMap.insert(
403	TextureUnitTargetMap::value_type(target, tex));
404
405	// Get image
406	XSI::CRef src = shader.GetParameter(L"Texture").GetSource();
407	if (!src.IsValid() \|\| !src.IsA(XSI::siImageClipID))
408	{
409	// Try Texture_1 (OGL Combined)
410	src = shader.GetParameter(L"Texture_1").GetSource();
411
412	}
413	if (src.IsValid() && src.IsA(XSI::siImageClipID))
414	{
415	XSI::ImageClip imgClip(src);
416	String srcTextureName =
417	XSItoOgre(imgClip.GetParameter(L"SourceFileName").GetValue());
418
419	String::size_type pos = srcTextureName.find_last_of("\\");
420	if (pos == String::npos)
421	{
422	pos = srcTextureName.find_last_of("/");
423	}
424	String textureName =
425	srcTextureName.substr(pos+1, srcTextureName.size() - pos - 1);
426	String destTextureName = targetFolder + textureName;
427
428	// copy texture if required
429	if (copyTextures)
430	{
431	copyFile(srcTextureName, destTextureName);
432	}
433
434	LogOgreAndXSI("Adding texture " + textureName);
435	tex->setTextureName(textureName);
436
437	}
438
439	return tex;
440	}
441	//-------------------------------------------------------------------------
442	void XsiMaterialExporter::populateOGLFiltering(TextureUnitState* tex,
443	XSI::Shader& shader)
444	{
445	FilterOptions minFilter, mipFilter, magFilter;
446	minFilter = FO_LINEAR;
447	magFilter = FO_LINEAR;
448	mipFilter = FO_POINT;
449	XSI::Parameter param = shader.GetParameter(L"minfilter");
450	if (param.IsValid())
451	{
452	// XSI OGL shader uses minfilter to determine mip too
453	long filt = param.GetValue();
454	switch(filt)
455	{
456	case 0:
457	minFilter = FO_POINT;
458	mipFilter = FO_NONE;
459	break;
460	case 1:
461	minFilter = FO_LINEAR;
462	mipFilter = FO_NONE;
463	break;
464	case 2:
465	minFilter = FO_POINT;
466	mipFilter = FO_POINT;
467	break;
468	case 3:
469	minFilter = FO_POINT;
470	mipFilter = FO_LINEAR;
471	break;
472	case 4:
473	minFilter = FO_LINEAR;
474	mipFilter = FO_POINT;
475	break;
476	case 5:
477	minFilter = FO_LINEAR;
478	mipFilter = FO_LINEAR;
479	break;
480	};
481
482	}
483	param = shader.GetParameter(L"magfilter");
484	if (param.IsValid())
485	{
486	long filt = param.GetValue();
487	switch(filt)
488	{
489	case 0:
490	magFilter = FO_POINT;
491	break;
492	case 1:
493	magFilter = FO_LINEAR;
494	break;
495	};
496	}
497
498	param = shader.GetParameter(L"anisotropy");
499	if (param.IsValid())
500	{
501	long aniso = param.GetValue();
502	if (aniso > 1)
503	{
504	// No specific aniso filtering option, so upgrade linear -> aniso
505	if (minFilter == FO_LINEAR)
506	minFilter = FO_ANISOTROPIC;
507	if (magFilter == FO_LINEAR)
508	magFilter = FO_ANISOTROPIC;
509	}
510	tex->setTextureAnisotropy(aniso);
511	}
512
513	tex->setTextureFiltering(minFilter, magFilter, mipFilter);
514	}
515	//-------------------------------------------------------------------------
516	void XsiMaterialExporter::populateDXFiltering(TextureUnitState* tex,
517	XSI::Shader& shader)
518	{
519	FilterOptions minFilter, mipFilter, magFilter;
520	minFilter = FO_LINEAR;
521	magFilter = FO_LINEAR;
522	mipFilter = FO_POINT;
523	XSI::Parameter param = shader.GetParameter(L"minfilter");
524	if (param.IsValid())
525	{
526	// XSI DX shader has min/mag and mip, and has more options
527	long filt = param.GetValue();
528	switch(filt)
529	{
530	case 0:
531	minFilter = FO_NONE;
532	break;
533	case 1:
534	minFilter = FO_POINT;
535	break;
536	case 2:
537	minFilter = FO_LINEAR;
538	break;
539	case 3:
540	case 4: // we don't support cubic/gaussian, use aniso
541	case 5:
542	minFilter = FO_ANISOTROPIC;
543	break;
544	};
545	}
546	param = shader.GetParameter(L"magfilter");
547	if (param.IsValid())
548	{
549	// XSI DX shader has mag/mag and mip, and has more options
550	long filt = param.GetValue();
551	switch(filt)
552	{
553	case 0:
554	magFilter = FO_NONE;
555	break;
556	case 1:
557	magFilter = FO_POINT;
558	break;
559	case 2:
560	magFilter = FO_LINEAR;
561	break;
562	case 3:
563	case 4: // we don't support cubic/gaussian, use aniso
564	case 5:
565	magFilter = FO_ANISOTROPIC;
566	break;
567	};
568	}
569	param = shader.GetParameter(L"mipfilter");
570	if (param.IsValid())
571	{
572	// XSI DX shader has mip/mag and mip, and has more options
573	long filt = param.GetValue();
574	switch(filt)
575	{
576	case 0:
577	mipFilter = FO_NONE;
578	break;
579	case 1:
580	mipFilter = FO_POINT;
581	break;
582	case 2:
583	mipFilter = FO_LINEAR;
584	break;
585	case 3:
586	case 4: // we don't support cubic/gaussian, use aniso
587	case 5:
588	mipFilter = FO_ANISOTROPIC;
589	break;
590	};
591	}
592	// Aniso
593	param = shader.GetParameter(L"anisotropy");
594	if (param.IsValid())
595	{
596	long aniso = param.GetValue();
597	tex->setTextureAnisotropy(aniso);
598	}
599
600	tex->setTextureFiltering(minFilter, magFilter, mipFilter);
601	}
602	//-------------------------------------------------------------------------
603	TextureUnitState* XsiMaterialExporter::addCubicTexture(Pass* pass, XSI::Shader& shader,
604	bool copyTextures, const String& targetFolder)
605	{
606	// create texture unit state and map from target incase future xforms
607	TextureUnitState* tex = pass->createTextureUnitState();
608
609	XSI::Parameter param = shader.GetParameter(L"target"); // OGL
610	if (!param.IsValid())
611	param = shader.GetParameter(L"Texture_Target"); // DX
612
613	long target = param.GetValue();
614	mTextureUnitTargetMap.insert(
615	TextureUnitTargetMap::value_type(target, tex));
616
617	// Get images
618	wchar_t* cubeFaceName[6] = {
619	L"front", L"back", L"top", L"bottom", L"left", L"right" };
620
621	String finalNames[6];
622
623
624	for (int face = 0; face < 6; ++face)
625	{
626	XSI::CRef src = shader.GetParameter(cubeFaceName[face]).GetSource();
627	if (src.IsValid() && src.IsA(XSI::siImageClipID))
628	{
629	XSI::ImageClip imgClip(src);
630	String srcTextureName =
631	XSItoOgre(imgClip.GetParameter(L"SourceFileName").GetValue());
632
633	String::size_type pos = srcTextureName.find_last_of("\\");
634	if (pos == String::npos)
635	{
636	pos = srcTextureName.find_last_of("/");
637	}
638	finalNames[face] =
639	srcTextureName.substr(pos+1, srcTextureName.size() - pos - 1);
640	String destTextureName = targetFolder + finalNames[face];
641
642	// copy texture if required
643	if (copyTextures)
644	{
645	copyFile(srcTextureName, destTextureName);
646	}
647
648
649	LogOgreAndXSI("Cubemap face: " + srcTextureName);
650	}
651	}
652
653	LogOgreAndXSI("Adding cubic texture");
654	// Cannot do combinedUVW for now, DevIL can't write DDS cubemap so
655	// go for separates (user can modify)
656	tex->setCubicTextureName(finalNames, false);
657
658	return tex;
659
660	}
661	//-------------------------------------------------------------------------
662	unsigned short XsiMaterialExporter::getTextureCoordIndex(const String& tspace)
663	{
664	TextureProjectionMap::iterator i = mTextureProjectionMap.find(tspace);
665	if (i != mTextureProjectionMap.end())
666	{
667	return i->second;
668	}
669	else
670	{
671	// default
672	return 0;
673	}
674	}
675	//-------------------------------------------------------------------------
676	void XsiMaterialExporter::populatePassTextureTransforms(Pass* pass,
677	XSI::Shader& shader)
678	{
679	// TODO
680	// Check we have the right object
681	XSI::Parameter param = shader.GetParameter(L"wrap_u");
682	if (param.IsValid())
683	{
684
685	// addressing mode
686	TextureUnitState::UVWAddressingMode uvwadd;
687	uvwadd.u = convertAddressingMode(param.GetValue());
688	// default other dimensions incase not supplied
689	uvwadd.v = uvwadd.u;
690	uvwadd.w = uvwadd.u;
691
692	param = shader.GetParameter(L"wrap_v");
693	if (param.IsValid())
694	{
695	uvwadd.v = convertAddressingMode(param.GetValue());
696	}
697	param = shader.GetParameter(L"wrap_w");
698	if (param.IsValid())
699	{
700	uvwadd.w = convertAddressingMode(param.GetValue());
701	}
702
703	// transform
704	bool usexform = false;
705	Matrix4 xform = Matrix4::IDENTITY;
706	param = shader.GetParameter(L"Transform");
707	if (param.IsValid() && (bool)param.GetValue())
708	{
709	Quaternion qx, qy, qz, qfinal;
710	qx.FromAngleAxis(Degree(shader.GetParameter(L"rotx").GetValue()),
711	Vector3::UNIT_X);
712	qy.FromAngleAxis(Degree(shader.GetParameter(L"roty").GetValue()),
713	Vector3::UNIT_Y);
714	qz.FromAngleAxis(Degree(shader.GetParameter(L"rotz").GetValue()),
715	Vector3::UNIT_Z);
716	qfinal = qx * qy * qz;
717
718	Vector3 trans;
719	trans.x = shader.GetParameter(L"trsx").GetValue();
720	trans.y = shader.GetParameter(L"trsy").GetValue();
721	trans.z = shader.GetParameter(L"trsz").GetValue();
722
723	Matrix3 rot3x3, scale3x3;
724	qfinal.ToRotationMatrix(rot3x3);
725	scale3x3 = Matrix3::ZERO;
726	scale3x3[0][0] = shader.GetParameter(L"sclx").GetValue();
727	scale3x3[1][1] = shader.GetParameter(L"scly").GetValue();
728	scale3x3[2][2] = shader.GetParameter(L"sclz").GetValue();
729
730	xform = rot3x3 * scale3x3;
731	xform.setTrans(trans);
732	usexform = true;
733
734	}
735
736
737	// Look up texture unit(s) that are using this target
738	long target = shader.GetParameter(L"Texture_Target").GetValue();
739	TextureUnitTargetMap::iterator i = mTextureUnitTargetMap.find(target);
740	while (i != mTextureUnitTargetMap.end() && i->first == target)
741	{
742	TextureUnitState* tex = i->second;
743	tex->setTextureAddressingMode(uvwadd);
744	if (usexform)
745	tex->setTextureTransform(xform);
746
747	// texgen (not texcoord_index as in OGRE!)
748	// Can turn into 2 different calls
749	param = shader.GetParameter(L"texcoord_index");
750	if (param.IsValid())
751	{
752	long e = param.GetValue();
753	if (e != 0)
754	{
755	// Not Explicit
756	// details differ per DX/OGL
757	if (XSItoOgre(shader.GetProgID()).find("DX") != String::npos)
758	{
759	convertTexGenDX(tex, e, shader);
760	}
761	else
762	{
763	convertTexGenDX(tex, e, shader);
764	}
765
766	}
767
768	}
769	++i;
770	}
771
772
773
774
775	}
776	param = shader.GetParameter(L"Additive_Transform");
777	if (param.IsValid())
778	{
779	unsigned short target = shader.GetParameter(L"Texture_Coord_ID").GetValue();
780	if (pass->getNumTextureUnitStates() > target)
781	{
782	TextureUnitState* tex = pass->getTextureUnitState(target);
783
784	long uvType = shader.GetParameter(L"UV_Type").GetValue();
785	if (uvType != 0)
786	{
787	double val1 = shader.GetParameter(L"Val1").GetValue();
788	double val2 = shader.GetParameter(L"Val2").GetValue();
789	long wave = shader.GetParameter(L"Wave").GetValue();
790	WaveformType wft;
791	switch (wave)
792	{
793	case 1:
794	wft = WFT_SINE;
795	break;
796	case 2:
797	wft = WFT_TRIANGLE;
798	break;
799	case 3:
800	wft = WFT_SQUARE;
801	break;
802	case 4:
803	wft = WFT_SAWTOOTH;
804	break;
805	case 5:
806	wft = WFT_INVERSE_SAWTOOTH;
807	break;
808	}
809	double base = shader.GetParameter(L"Base").GetValue();
810	double amp = shader.GetParameter(L"Amplitude").GetValue();
811	double phase = shader.GetParameter(L"Phase").GetValue();
812	double freq = shader.GetParameter(L"Frequency").GetValue();
813
814	switch(uvType)
815	{
816	case 1:
817	// translate
818	tex->setTextureScroll(val1, val2);
819	break;
820	case 2:
821	// rotate
822	tex->setTextureRotate(Degree(val1));
823	break;
824	case 3:
825	// scale
826	tex->setTextureScale(val1, val2);
827	break;
828	case 4:
829	// scroll
830	if (wave != 0)
831	{
832	tex->setTransformAnimation(TextureUnitState::TT_TRANSLATE_U,
833	wft, base, freq, phase, amp);
834	tex->setTransformAnimation(TextureUnitState::TT_TRANSLATE_V,
835	wft, base, freq, phase, amp);
836	}
837	else
838	{
839	tex->setScrollAnimation(val1, val2);
840	}
841	break;
842	case 5:
843	// turn
844	if (wave != 0)
845	{
846	tex->setTransformAnimation(TextureUnitState::TT_ROTATE,
847	wft, base, freq, phase, amp);
848	}
849	else
850	{
851	tex->setRotateAnimation(val1 / 360.0f);
852	}
853	break;
854	case 6:
855	// stretch (only wave)
856	if (wave != 0)
857	{
858	tex->setTransformAnimation(TextureUnitState::TT_SCALE_U,
859	wft, base, freq, phase, amp);
860	tex->setTransformAnimation(TextureUnitState::TT_SCALE_V,
861	wft, base, freq, phase, amp);
862	}
863	break;
864
865	}
866	}
867	}
868
869	}
870
871	// if more than one entry for the same target is found, it is ok for the
872	// latter to take precedence since this is what happens in XSI.
873
874	}
875	//-------------------------------------------------------------------------
876	void XsiMaterialExporter::convertTexGenOGL(TextureUnitState* tex,
877	long xsiVal, XSI::Shader& shader)
878	{
879	switch(xsiVal)
880	{
881	// no 0
882	case 1:
883	// Object linear
884	tex->setEnvironmentMap(true, TextureUnitState::ENV_PLANAR);
885	break;
886	case 2:
887	// Eye linear (texture projection)
888	tex->setProjectiveTexturing(true);
889	break;
890	case 3:
891	// Sphere map
892	tex->setEnvironmentMap(true, TextureUnitState::ENV_CURVED);
893	break;
894	case 4:
895	// Reflection map
896	tex->setEnvironmentMap(true, TextureUnitState::ENV_REFLECTION);
897	break;
898	case 5:
899	// Normal map
900	tex->setEnvironmentMap(true, TextureUnitState::ENV_NORMAL);
901	break;
902
903	};
904	}
905	//-------------------------------------------------------------------------
906	void XsiMaterialExporter::convertTexGenDX(TextureUnitState* tex,
907	long xsiVal, XSI::Shader& shader)
908	{
909	switch(xsiVal)
910	{
911	// no 0
912	case 1:
913	// Normal in camera space
914	tex->setEnvironmentMap(true, TextureUnitState::ENV_CURVED);
915	break;
916	case 2:
917	// Position in camera space
918	tex->setEnvironmentMap(true, TextureUnitState::ENV_PLANAR);
919	break;
920	case 3:
921	// Reflection vector in camera space
922	tex->setEnvironmentMap(true, TextureUnitState::ENV_REFLECTION);
923	break;
924
925	};
926	}
927	//-------------------------------------------------------------------------
928	TextureUnitState::TextureAddressingMode
929	XsiMaterialExporter::convertAddressingMode(short xsiVal)
930	{
931	// same for OGL and DX
932	switch(xsiVal)
933	{
934	case 0:
935	return TextureUnitState::TAM_WRAP;
936	case 1:
937	return TextureUnitState::TAM_MIRROR;
938	case 2:
939	return TextureUnitState::TAM_CLAMP;
940	case 3:
941	// border?
942	return TextureUnitState::TAM_CLAMP;
943	case 4:
944	// mirror once
945	return TextureUnitState::TAM_MIRROR;
946	case 5:
947	// clamp to edge
948	return TextureUnitState::TAM_CLAMP;
949
950	};
951
952	// Keep compiler happy
953	return TextureUnitState::TAM_WRAP;
954	}
955	//-------------------------------------------------------------------------
956	SceneBlendFactor XsiMaterialExporter::convertSceneBlend(short xsiVal)
957	{
958	switch(xsiVal)
959	{
960	case 0:
961	return SBF_ZERO;
962	case 1:
963	return SBF_ONE;
964	case 2:
965	return SBF_DEST_COLOUR;
966	case 3:
967	return SBF_ONE_MINUS_DEST_COLOUR;
968	case 4:
969	return SBF_SOURCE_ALPHA;
970	case 5:
971	return SBF_ONE_MINUS_SOURCE_ALPHA;
972	case 6:
973	return SBF_DEST_ALPHA;
974	case 7:
975	return SBF_ONE_MINUS_DEST_ALPHA;
976	};
977
978	return SBF_ZERO;
979
980	}
981
982	}
983

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: OGRE/trunk/ogrenew/Tools/XSIExport/src/OgreXSIMaterialExporter.cpp @ 692

Download in other formats: