Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

OgreXSIMaterialExporter.cpp @ 11

Last change on this file since 11 was 6, checked in by anonymous, 17 years ago
=…
File size: 26.0 KB

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

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

Context Navigation

source: downloads/ogre/Tools/XSIExport/src/OgreXSIMaterialExporter.cpp @ 11

Download in other formats: