fix for bugs
[bf-blender-Bug Tracker][6693] x3d export bug in V2.44 release [bf-blender-Bug Tracker][7773] .x3d exporter problems (moving meshes away) Updated how objects are transformed, and use Mesh rather then NMesh. also removed vertex color saving since it was really slow and vcolors are stored per face in blender.
This commit is contained in:
Campbell Barton
@@ -1,15 +1,12 @@
|
||||
#!BPY
|
||||
""" Registration info for Blender menus:
|
||||
Name: 'X3D Extensible 3D (.x3d)...'
|
||||
Blender: 235
|
||||
Blender: 245
|
||||
Group: 'Export'
|
||||
Submenu: 'All Objects...' all
|
||||
Submenu: 'All Objects compressed...' comp
|
||||
Submenu: 'Selected Objects...' selected
|
||||
Tooltip: 'Export to Extensible 3D file (.x3d)'
|
||||
Tooltip: 'Export selection to Extensible 3D file (.x3d)'
|
||||
"""
|
||||
|
||||
__author__ = ("Bart")
|
||||
__author__ = ("Bart", "Campbell Barton")
|
||||
__email__ = ["Bart, bart:neeneenee*de"]
|
||||
__url__ = ["Author's (Bart) homepage, http://www.neeneenee.de/vrml"]
|
||||
__version__ = "2006/01/17"
|
||||
@@ -22,10 +19,9 @@ Run this script from "File->Export" menu. A pop-up will ask whether you
|
||||
want to export only selected or all relevant objects.
|
||||
|
||||
Known issues:<br>
|
||||
Doesn't handle multiple materials (don't use material indices);<br>
|
||||
Doesn't handle multiple UV textures on a single mesh (create a mesh
|
||||
for each texture);<br>
|
||||
Can't get the texture array associated with material * not the UV ones;
|
||||
Doesn't handle multiple materials (don't use material indices);<br>
|
||||
Doesn't handle multiple UV textures on a single mesh (create a mesh for each texture);<br>
|
||||
Can't get the texture array associated with material * not the UV ones;
|
||||
"""
|
||||
|
||||
|
||||
@@ -58,953 +54,903 @@ for each texture);<br>
|
||||
####################################
|
||||
|
||||
import Blender
|
||||
from Blender import Object, NMesh, Lamp, Draw, Image, Text, sys
|
||||
from Blender import Object, Lamp, Draw, Image, Text, sys, Mesh
|
||||
from Blender.Scene import Render
|
||||
import math
|
||||
|
||||
#
|
||||
DEG2RAD=0.017453292519943295
|
||||
MATWORLD= Blender.Mathutils.RotationMatrix(-90, 4, 'x')
|
||||
|
||||
####################################
|
||||
# Global Variables
|
||||
####################################
|
||||
|
||||
scene = Blender.Scene.GetCurrent()
|
||||
world = Blender.World.GetCurrent()
|
||||
worldmat = Blender.Texture.Get()
|
||||
filename = Blender.Get('filename')
|
||||
_safeOverwrite = True
|
||||
ARG=''
|
||||
extension = ''
|
||||
|
||||
class DrawTypes:
|
||||
"""Object DrawTypes enum values
|
||||
BOUNDS - draw only the bounding box of the object
|
||||
WIRE - draw object as a wire frame
|
||||
SOLID - draw object with flat shading
|
||||
SHADED - draw object with OpenGL shading
|
||||
"""
|
||||
BOUNDBOX = 1
|
||||
WIRE = 2
|
||||
SOLID = 3
|
||||
SHADED = 4
|
||||
TEXTURE = 5
|
||||
|
||||
if not hasattr(Blender.Object,'DrawTypes'):
|
||||
Blender.Object.DrawTypes = DrawTypes()
|
||||
|
||||
##########################################################
|
||||
# Functions for writing output file
|
||||
##########################################################
|
||||
|
||||
class VRML2Export:
|
||||
|
||||
def __init__(self, filename):
|
||||
#--- public you can change these ---
|
||||
self.writingcolor = 0
|
||||
self.writingtexture = 0
|
||||
self.writingcoords = 0
|
||||
self.wire = 0
|
||||
self.proto = 1
|
||||
self.matonly = 0
|
||||
self.share = 0
|
||||
self.billnode = 0
|
||||
self.halonode = 0
|
||||
self.collnode = 0
|
||||
self.tilenode = 0
|
||||
self.verbose=2 # level of verbosity in console 0-none, 1-some, 2-most
|
||||
self.cp=3 # decimals for material color values 0.000 - 1.000
|
||||
self.vp=3 # decimals for vertex coordinate values 0.000 - n.000
|
||||
self.tp=3 # decimals for texture coordinate values 0.000 - 1.000
|
||||
self.it=3
|
||||
|
||||
#--- class private don't touch ---
|
||||
self.texNames={} # dictionary of textureNames
|
||||
self.matNames={} # dictionary of materiaNames
|
||||
self.meshNames={} # dictionary of meshNames
|
||||
self.indentLevel=0 # keeps track of current indenting
|
||||
self.filename=filename
|
||||
self.file = open(filename, "w")
|
||||
self.bNav=0
|
||||
self.nodeID=0
|
||||
self.namesReserved=[ "Anchor","Appearance","Arc2D","ArcClose2D","AudioClip","Background","Billboard",
|
||||
"BooleanFilter","BooleanSequencer","BooleanToggle","BooleanTrigger","Box","Circle2D",
|
||||
"Collision","Color","ColorInterpolator","ColorRGBA","component","Cone","connect",
|
||||
"Contour2D","ContourPolyline2D","Coordinate","CoordinateDouble","CoordinateInterpolator",
|
||||
"CoordinateInterpolator2D","Cylinder","CylinderSensor","DirectionalLight","Disk2D",
|
||||
"ElevationGrid","EspduTransform","EXPORT","ExternProtoDeclare","Extrusion","field",
|
||||
"fieldValue","FillProperties","Fog","FontStyle","GeoCoordinate","GeoElevationGrid",
|
||||
"GeoLocationLocation","GeoLOD","GeoMetadata","GeoOrigin","GeoPositionInterpolator",
|
||||
"GeoTouchSensor","GeoViewpoint","Group","HAnimDisplacer","HAnimHumanoid","HAnimJoint",
|
||||
"HAnimSegment","HAnimSite","head","ImageTexture","IMPORT","IndexedFaceSet",
|
||||
"IndexedLineSet","IndexedTriangleFanSet","IndexedTriangleSet","IndexedTriangleStripSet",
|
||||
"Inline","IntegerSequencer","IntegerTrigger","IS","KeySensor","LineProperties","LineSet",
|
||||
"LoadSensor","LOD","Material","meta","MetadataDouble","MetadataFloat","MetadataInteger",
|
||||
"MetadataSet","MetadataString","MovieTexture","MultiTexture","MultiTextureCoordinate",
|
||||
"MultiTextureTransform","NavigationInfo","Normal","NormalInterpolator","NurbsCurve",
|
||||
"NurbsCurve2D","NurbsOrientationInterpolator","NurbsPatchSurface",
|
||||
"NurbsPositionInterpolator","NurbsSet","NurbsSurfaceInterpolator","NurbsSweptSurface",
|
||||
"NurbsSwungSurface","NurbsTextureCoordinate","NurbsTrimmedSurface","OrientationInterpolator",
|
||||
"PixelTexture","PlaneSensor","PointLight","PointSet","Polyline2D","Polypoint2D",
|
||||
"PositionInterpolator","PositionInterpolator2D","ProtoBody","ProtoDeclare","ProtoInstance",
|
||||
"ProtoInterface","ProximitySensor","ReceiverPdu","Rectangle2D","ROUTE","ScalarInterpolator",
|
||||
"Scene","Script","Shape","SignalPdu","Sound","Sphere","SphereSensor","SpotLight","StaticGroup",
|
||||
"StringSensor","Switch","Text","TextureBackground","TextureCoordinate","TextureCoordinateGenerator",
|
||||
"TextureTransform","TimeSensor","TimeTrigger","TouchSensor","Transform","TransmitterPdu",
|
||||
"TriangleFanSet","TriangleSet","TriangleSet2D","TriangleStripSet","Viewpoint","VisibilitySensor",
|
||||
"WorldInfo","X3D","XvlShell","VertexShader","FragmentShader","MultiShaderAppearance","ShaderAppearance" ]
|
||||
self.namesStandard=[ "Empty","Empty.000","Empty.001","Empty.002","Empty.003","Empty.004","Empty.005",
|
||||
"Empty.006","Empty.007","Empty.008","Empty.009","Empty.010","Empty.011","Empty.012",
|
||||
"Scene.001","Scene.002","Scene.003","Scene.004","Scene.005","Scene.06","Scene.013",
|
||||
"Scene.006","Scene.007","Scene.008","Scene.009","Scene.010","Scene.011","Scene.012",
|
||||
"World","World.000","World.001","World.002","World.003","World.004","World.005" ]
|
||||
self.namesFog=[ "","LINEAR","EXPONENTIAL","" ]
|
||||
def __init__(self, filename):
|
||||
#--- public you can change these ---
|
||||
self.writingcolor = 0
|
||||
self.writingtexture = 0
|
||||
self.writingcoords = 0
|
||||
self.proto = 1
|
||||
self.matonly = 0
|
||||
self.share = 0
|
||||
self.billnode = 0
|
||||
self.halonode = 0
|
||||
self.collnode = 0
|
||||
self.tilenode = 0
|
||||
self.verbose=2 # level of verbosity in console 0-none, 1-some, 2-most
|
||||
self.cp=3 # decimals for material color values 0.000 - 1.000
|
||||
self.vp=3 # decimals for vertex coordinate values 0.000 - n.000
|
||||
self.tp=3 # decimals for texture coordinate values 0.000 - 1.000
|
||||
self.it=3
|
||||
|
||||
#--- class private don't touch ---
|
||||
self.texNames={} # dictionary of textureNames
|
||||
self.matNames={} # dictionary of materiaNames
|
||||
self.meshNames={} # dictionary of meshNames
|
||||
self.indentLevel=0 # keeps track of current indenting
|
||||
self.filename=filename
|
||||
self.file = open(filename, "w")
|
||||
self.bNav=0
|
||||
self.nodeID=0
|
||||
self.namesReserved=[ "Anchor","Appearance","Arc2D","ArcClose2D","AudioClip","Background","Billboard",
|
||||
"BooleanFilter","BooleanSequencer","BooleanToggle","BooleanTrigger","Box","Circle2D",
|
||||
"Collision","Color","ColorInterpolator","ColorRGBA","component","Cone","connect",
|
||||
"Contour2D","ContourPolyline2D","Coordinate","CoordinateDouble","CoordinateInterpolator",
|
||||
"CoordinateInterpolator2D","Cylinder","CylinderSensor","DirectionalLight","Disk2D",
|
||||
"ElevationGrid","EspduTransform","EXPORT","ExternProtoDeclare","Extrusion","field",
|
||||
"fieldValue","FillProperties","Fog","FontStyle","GeoCoordinate","GeoElevationGrid",
|
||||
"GeoLocationLocation","GeoLOD","GeoMetadata","GeoOrigin","GeoPositionInterpolator",
|
||||
"GeoTouchSensor","GeoViewpoint","Group","HAnimDisplacer","HAnimHumanoid","HAnimJoint",
|
||||
"HAnimSegment","HAnimSite","head","ImageTexture","IMPORT","IndexedFaceSet",
|
||||
"IndexedLineSet","IndexedTriangleFanSet","IndexedTriangleSet","IndexedTriangleStripSet",
|
||||
"Inline","IntegerSequencer","IntegerTrigger","IS","KeySensor","LineProperties","LineSet",
|
||||
"LoadSensor","LOD","Material","meta","MetadataDouble","MetadataFloat","MetadataInteger",
|
||||
"MetadataSet","MetadataString","MovieTexture","MultiTexture","MultiTextureCoordinate",
|
||||
"MultiTextureTransform","NavigationInfo","Normal","NormalInterpolator","NurbsCurve",
|
||||
"NurbsCurve2D","NurbsOrientationInterpolator","NurbsPatchSurface",
|
||||
"NurbsPositionInterpolator","NurbsSet","NurbsSurfaceInterpolator","NurbsSweptSurface",
|
||||
"NurbsSwungSurface","NurbsTextureCoordinate","NurbsTrimmedSurface","OrientationInterpolator",
|
||||
"PixelTexture","PlaneSensor","PointLight","PointSet","Polyline2D","Polypoint2D",
|
||||
"PositionInterpolator","PositionInterpolator2D","ProtoBody","ProtoDeclare","ProtoInstance",
|
||||
"ProtoInterface","ProximitySensor","ReceiverPdu","Rectangle2D","ROUTE","ScalarInterpolator",
|
||||
"Scene","Script","Shape","SignalPdu","Sound","Sphere","SphereSensor","SpotLight","StaticGroup",
|
||||
"StringSensor","Switch","Text","TextureBackground","TextureCoordinate","TextureCoordinateGenerator",
|
||||
"TextureTransform","TimeSensor","TimeTrigger","TouchSensor","Transform","TransmitterPdu",
|
||||
"TriangleFanSet","TriangleSet","TriangleSet2D","TriangleStripSet","Viewpoint","VisibilitySensor",
|
||||
"WorldInfo","X3D","XvlShell","VertexShader","FragmentShader","MultiShaderAppearance","ShaderAppearance" ]
|
||||
self.namesStandard=[ "Empty","Empty.000","Empty.001","Empty.002","Empty.003","Empty.004","Empty.005",
|
||||
"Empty.006","Empty.007","Empty.008","Empty.009","Empty.010","Empty.011","Empty.012",
|
||||
"Scene.001","Scene.002","Scene.003","Scene.004","Scene.005","Scene.06","Scene.013",
|
||||
"Scene.006","Scene.007","Scene.008","Scene.009","Scene.010","Scene.011","Scene.012",
|
||||
"World","World.000","World.001","World.002","World.003","World.004","World.005" ]
|
||||
self.namesFog=[ "","LINEAR","EXPONENTIAL","" ]
|
||||
|
||||
##########################################################
|
||||
# Writing nodes routines
|
||||
##########################################################
|
||||
|
||||
def writeHeader(self):
|
||||
#bfile = sys.expandpath( Blender.Get('filename') ).replace('<', '<').replace('>', '>')
|
||||
bfile = self.filename.replace('<', '<').replace('>', '>') # use outfile name
|
||||
self.file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
|
||||
self.file.write("<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D 3.0//EN\" \"http://www.web3d.org/specifications/x3d-3.0.dtd\">\n")
|
||||
self.file.write("<X3D version=\"3.0\" profile=\"Immersive\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema-instance\" xsd:noNamespaceSchemaLocation=\"http://www.web3d.org/specifications/x3d-3.0.xsd\">\n")
|
||||
self.file.write("<head>\n")
|
||||
self.file.write("\t<meta name=\"filename\" content=\"%s\" />\n" % sys.basename(bfile))
|
||||
self.file.write("\t<meta name=\"generator\" content=\"Blender %s\" />\n" % Blender.Get('version'))
|
||||
self.file.write("\t<meta name=\"translator\" content=\"X3D exporter v1.55 (2006/01/17)\" />\n")
|
||||
self.file.write("</head>\n")
|
||||
self.file.write("<Scene>\n")
|
||||
def writeHeader(self):
|
||||
#bfile = sys.expandpath( Blender.Get('filename') ).replace('<', '<').replace('>', '>')
|
||||
bfile = self.filename.replace('<', '<').replace('>', '>') # use outfile name
|
||||
self.file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
|
||||
self.file.write("<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D 3.0//EN\" \"http://www.web3d.org/specifications/x3d-3.0.dtd\">\n")
|
||||
self.file.write("<X3D version=\"3.0\" profile=\"Immersive\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema-instance\" xsd:noNamespaceSchemaLocation=\"http://www.web3d.org/specifications/x3d-3.0.xsd\">\n")
|
||||
self.file.write("<head>\n")
|
||||
self.file.write("\t<meta name=\"filename\" content=\"%s\" />\n" % sys.basename(bfile))
|
||||
self.file.write("\t<meta name=\"generator\" content=\"Blender %s\" />\n" % Blender.Get('version'))
|
||||
self.file.write("\t<meta name=\"translator\" content=\"X3D exporter v1.55 (2006/01/17)\" />\n")
|
||||
self.file.write("</head>\n")
|
||||
self.file.write("<Scene>\n")
|
||||
|
||||
# This functionality is poorly defined, disabling for now - campbell
|
||||
'''
|
||||
def writeInline(self):
|
||||
inlines = Blender.Scene.Get()
|
||||
allinlines = len(inlines)
|
||||
if scene != inlines[0]:
|
||||
return
|
||||
else:
|
||||
for i in xrange(allinlines):
|
||||
nameinline=inlines[i].name
|
||||
if (nameinline not in self.namesStandard) and (i > 0):
|
||||
self.file.write("<Inline DEF=\"%s\" " % (self.cleanStr(nameinline)))
|
||||
nameinline = nameinline+".x3d"
|
||||
self.file.write("url=\"%s\" />" % nameinline)
|
||||
self.file.write("\n\n")
|
||||
'''
|
||||
|
||||
def writeScript(self):
|
||||
textEditor = Blender.Text.Get()
|
||||
alltext = len(textEditor)
|
||||
for i in xrange(alltext):
|
||||
nametext = textEditor[i].name
|
||||
nlines = textEditor[i].getNLines()
|
||||
if (self.proto == 1):
|
||||
if (nametext == "proto" or nametext == "proto.js" or nametext == "proto.txt") and (nlines != None):
|
||||
nalllines = len(textEditor[i].asLines())
|
||||
alllines = textEditor[i].asLines()
|
||||
for j in xrange(nalllines):
|
||||
self.writeIndented(alllines[j] + "\n")
|
||||
elif (self.proto == 0):
|
||||
if (nametext == "route" or nametext == "route.js" or nametext == "route.txt") and (nlines != None):
|
||||
nalllines = len(textEditor[i].asLines())
|
||||
alllines = textEditor[i].asLines()
|
||||
for j in xrange(nalllines):
|
||||
self.writeIndented(alllines[j] + "\n")
|
||||
self.writeIndented("\n")
|
||||
|
||||
def writeInline(self):
|
||||
inlines = Blender.Scene.Get()
|
||||
allinlines = len(inlines)
|
||||
if scene != inlines[0]:
|
||||
return
|
||||
else:
|
||||
for i in xrange(allinlines):
|
||||
nameinline=inlines[i].name
|
||||
if (nameinline not in self.namesStandard) and (i > 0):
|
||||
self.file.write("<Inline DEF=\"%s\" " % (self.cleanStr(nameinline)))
|
||||
nameinline = nameinline+".x3d"
|
||||
self.file.write("url=\"%s\" />" % nameinline)
|
||||
self.file.write("\n\n")
|
||||
def writeViewpoint(self, ob, scene):
|
||||
context = scene.render
|
||||
ratio = float(context.imageSizeY())/float(context.imageSizeX())
|
||||
lens = (360* (math.atan(ratio *16 / ob.data.getLens()) / math.pi))*(math.pi/180)
|
||||
lens = min(lens, math.pi)
|
||||
|
||||
# get the camera location, subtract 90 degress from X to orient like X3D does
|
||||
mat = ob.matrixWorld
|
||||
loc = self.rotatePointForVRML(mat.translationPart())
|
||||
rot = mat.toEuler()
|
||||
rot = (((rot[0]-90)*DEG2RAD), rot[1]*DEG2RAD, rot[2]*DEG2RAD)
|
||||
nRot = self.rotatePointForVRML( rot )
|
||||
# convert to Quaternion and to Angle Axis
|
||||
Q = self.eulerToQuaternions(nRot[0], nRot[1], nRot[2])
|
||||
Q1 = self.multiplyQuaternions(Q[0], Q[1])
|
||||
Qf = self.multiplyQuaternions(Q1, Q[2])
|
||||
angleAxis = self.quaternionToAngleAxis(Qf)
|
||||
self.file.write("<Viewpoint DEF=\"%s\" " % (self.cleanStr(ob.name)))
|
||||
self.file.write("description=\"%s\" " % (ob.name))
|
||||
self.file.write("centerOfRotation=\"0 0 0\" ")
|
||||
self.file.write("position=\"%3.2f %3.2f %3.2f\" " % (loc[0], loc[1], loc[2]))
|
||||
self.file.write("orientation=\"%3.2f %3.2f %3.2f %3.2f\" " % (angleAxis[0], angleAxis[1], -angleAxis[2], angleAxis[3]))
|
||||
self.file.write("fieldOfView=\"%.3f\" />\n\n" % (lens))
|
||||
|
||||
def writeScript(self):
|
||||
textEditor = Blender.Text.Get()
|
||||
alltext = len(textEditor)
|
||||
for i in xrange(alltext):
|
||||
nametext = textEditor[i].getName()
|
||||
nlines = textEditor[i].getNLines()
|
||||
if (self.proto == 1):
|
||||
if (nametext == "proto" or nametext == "proto.js" or nametext == "proto.txt") and (nlines != None):
|
||||
nalllines = len(textEditor[i].asLines())
|
||||
alllines = textEditor[i].asLines()
|
||||
for j in xrange(nalllines):
|
||||
self.writeIndented(alllines[j] + "\n")
|
||||
elif (self.proto == 0):
|
||||
if (nametext == "route" or nametext == "route.js" or nametext == "route.txt") and (nlines != None):
|
||||
nalllines = len(textEditor[i].asLines())
|
||||
alllines = textEditor[i].asLines()
|
||||
for j in xrange(nalllines):
|
||||
self.writeIndented(alllines[j] + "\n")
|
||||
self.writeIndented("\n")
|
||||
def writeFog(self, world):
|
||||
if world:
|
||||
mtype = world.getMistype()
|
||||
mparam = world.getMist()
|
||||
grd = world.getHor()
|
||||
grd0, grd1, grd2 = grd[0], grd[1], grd[2]
|
||||
else:
|
||||
return
|
||||
if (mtype == 1 or mtype == 2):
|
||||
self.file.write("<Fog fogType=\"%s\" " % self.namesFog[mtype])
|
||||
self.file.write("color=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("visibilityRange=\"%s\" />\n\n" % round(mparam[2],self.cp))
|
||||
else:
|
||||
return
|
||||
'''
|
||||
def writeNavigationInfo(self, scene):
|
||||
allObj = []
|
||||
allObj = list(scene.objects)
|
||||
headlight = "true"
|
||||
vislimit = 0.0
|
||||
for ob in allObj:
|
||||
objType=ob.type
|
||||
if objType == "Camera":
|
||||
vislimit = ob.data.clipEnd
|
||||
elif objType == "Lamp":
|
||||
headlight = "false"
|
||||
self.file.write("<NavigationInfo headlight=\"%s\" " % headlight)
|
||||
self.file.write("visibilityLimit=\"%s\" " % (round(vislimit,self.cp)))
|
||||
self.file.write("type=\"EXAMINE\", \"ANY\" avatarSize=\"0.25, 1.75, 0.75\" />\n\n")
|
||||
'''
|
||||
def writeSpotLight(self, ob, lamp, world):
|
||||
safeName = self.cleanStr(ob.name)
|
||||
if world:
|
||||
ambi = world.amb
|
||||
ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2]))/3)/2.5
|
||||
else:
|
||||
ambi = 0
|
||||
ambientIntensity = 0
|
||||
|
||||
def writeViewpoint(self, thisObj):
|
||||
context = scene.getRenderingContext()
|
||||
ratio = float(context.imageSizeY())/float(context.imageSizeX())
|
||||
lens = (360* (math.atan(ratio *16 / thisObj.data.getLens()) / math.pi))*(math.pi/180)
|
||||
lens = min(lens, math.pi)
|
||||
# get the camera location, subtract 90 degress from X to orient like X3D does
|
||||
loc = self.rotatePointForVRML(thisObj.loc)
|
||||
rot = [thisObj.RotX - 1.57, thisObj.RotY, thisObj.RotZ]
|
||||
nRot = self.rotatePointForVRML(rot)
|
||||
# convert to Quaternion and to Angle Axis
|
||||
Q = self.eulerToQuaternions(nRot[0], nRot[1], nRot[2])
|
||||
Q1 = self.multiplyQuaternions(Q[0], Q[1])
|
||||
Qf = self.multiplyQuaternions(Q1, Q[2])
|
||||
angleAxis = self.quaternionToAngleAxis(Qf)
|
||||
self.file.write("<Viewpoint DEF=\"%s\" " % (self.cleanStr(thisObj.name)))
|
||||
self.file.write("description=\"%s\" " % (thisObj.name))
|
||||
self.file.write("centerOfRotation=\"0 0 0\" ")
|
||||
self.file.write("position=\"%3.2f %3.2f %3.2f\" " % (loc[0], loc[1], loc[2]))
|
||||
self.file.write("orientation=\"%3.2f %3.2f %3.2f %3.2f\" " % (angleAxis[0], angleAxis[1], -angleAxis[2], angleAxis[3]))
|
||||
self.file.write("fieldOfView=\"%.3f\" />\n\n" % (lens))
|
||||
# compute cutoff and beamwidth
|
||||
intensity=min(lamp.energy/1.75,1.0)
|
||||
beamWidth=((lamp.spotSize*math.pi)/180.0)*.37;
|
||||
cutOffAngle=beamWidth*1.3
|
||||
|
||||
def writeFog(self):
|
||||
if world:
|
||||
mtype = world.getMistype()
|
||||
mparam = world.getMist()
|
||||
grd = world.getHor()
|
||||
grd0, grd1, grd2 = grd[0], grd[1], grd[2]
|
||||
else:
|
||||
return
|
||||
if (mtype == 1 or mtype == 2):
|
||||
self.file.write("<Fog fogType=\"%s\" " % self.namesFog[mtype])
|
||||
self.file.write("color=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("visibilityRange=\"%s\" />\n\n" % round(mparam[2],self.cp))
|
||||
else:
|
||||
return
|
||||
dx,dy,dz=self.computeDirection(ob)
|
||||
# note -dx seems to equal om[3][0]
|
||||
# note -dz seems to equal om[3][1]
|
||||
# note dy seems to equal om[3][2]
|
||||
|
||||
def writeNavigationInfo(self, scene):
|
||||
allObj = []
|
||||
allObj = list(scene.objects)
|
||||
headlight = "true"
|
||||
vislimit = 0.0
|
||||
for thisObj in allObj:
|
||||
objType=thisObj.type
|
||||
if objType == "Camera":
|
||||
vislimit = thisObj.data.clipEnd
|
||||
elif objType == "Lamp":
|
||||
headlight = "false"
|
||||
self.file.write("<NavigationInfo headlight=\"%s\" " % headlight)
|
||||
self.file.write("visibilityLimit=\"%s\" " % (round(vislimit,self.cp)))
|
||||
self.file.write("type=\"EXAMINE\", \"ANY\" avatarSize=\"0.25, 1.75, 0.75\" />\n\n")
|
||||
location=(ob.matrixWorld*MATWORLD).translationPart()
|
||||
radius = lamp.dist*math.cos(beamWidth)
|
||||
self.file.write("<SpotLight DEF=\"%s\" " % safeName)
|
||||
self.file.write("radius=\"%s\" " % (round(radius,self.cp)))
|
||||
self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity,self.cp)))
|
||||
self.file.write("intensity=\"%s\" " % (round(intensity,self.cp)))
|
||||
self.file.write("color=\"%s %s %s\" " % (round(lamp.col[0],self.cp), round(lamp.col[1],self.cp), round(lamp.col[2],self.cp)))
|
||||
self.file.write("beamWidth=\"%s\" " % (round(beamWidth,self.cp)))
|
||||
self.file.write("cutOffAngle=\"%s\" " % (round(cutOffAngle,self.cp)))
|
||||
self.file.write("direction=\"%s %s %s\" " % (round(dx,3),round(dy,3),round(dz,3)))
|
||||
self.file.write("location=\"%s %s %s\" />\n\n" % (round(location[0],3), round(location[1],3), round(location[2],3)))
|
||||
|
||||
|
||||
def writeDirectionalLight(self, ob, lamp, world):
|
||||
safeName = self.cleanStr(ob.name)
|
||||
if world:
|
||||
ambi = world.amb
|
||||
ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2]))/3)/2.5
|
||||
else:
|
||||
ambi = 0
|
||||
ambientIntensity = 0
|
||||
|
||||
def writeSpotLight(self, ob, lamp):
|
||||
safeName = self.cleanStr(ob.name)
|
||||
if world:
|
||||
ambi = world.amb
|
||||
ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2]))/3)/2.5
|
||||
else:
|
||||
ambi = 0
|
||||
ambientIntensity = 0
|
||||
intensity=min(lamp.energy/1.75,1.0)
|
||||
(dx,dy,dz)=self.computeDirection(ob)
|
||||
self.file.write("<DirectionalLight DEF=\"%s\" " % safeName)
|
||||
self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity,self.cp)))
|
||||
self.file.write("color=\"%s %s %s\" " % (round(lamp.col[0],self.cp), round(lamp.col[1],self.cp), round(lamp.col[2],self.cp)))
|
||||
self.file.write("intensity=\"%s\" " % (round(intensity,self.cp)))
|
||||
self.file.write("direction=\"%s %s %s\" />\n\n" % (round(dx,4),round(dy,4),round(dz,4)))
|
||||
|
||||
# compute cutoff and beamwidth
|
||||
intensity=min(lamp.energy/1.75,1.0)
|
||||
beamWidth=((lamp.spotSize*math.pi)/180.0)*.37;
|
||||
cutOffAngle=beamWidth*1.3
|
||||
def writePointLight(self, ob, lamp, world):
|
||||
safeName = self.cleanStr(ob.name)
|
||||
if world:
|
||||
ambi = world.amb
|
||||
ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2]))/3)/2.5
|
||||
else:
|
||||
ambi = 0
|
||||
ambientIntensity = 0
|
||||
|
||||
location=(ob.matrixWorld*MATWORLD).translationPart()
|
||||
intensity=min(lamp.energy/1.75,1.0)
|
||||
radius = lamp.dist
|
||||
self.file.write("<PointLight DEF=\"%s\" " % safeName)
|
||||
self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity,self.cp)))
|
||||
self.file.write("color=\"%s %s %s\" " % (round(lamp.col[0],self.cp), round(lamp.col[1],self.cp), round(lamp.col[2],self.cp)))
|
||||
self.file.write("intensity=\"%s\" " % (round(intensity,self.cp)))
|
||||
self.file.write("radius=\"%s\" " % radius )
|
||||
self.file.write("location=\"%s %s %s\" />\n\n" % (round(location[0],3), round(location[1],3), round(location[2],3)))
|
||||
|
||||
dx,dy,dz=self.computeDirection(ob)
|
||||
# note -dx seems to equal om[3][0]
|
||||
# note -dz seems to equal om[3][1]
|
||||
# note dy seems to equal om[3][2]
|
||||
def writeNode(self, ob):
|
||||
obname=str(ob.name)
|
||||
if obname in self.namesStandard:
|
||||
return
|
||||
else:
|
||||
dx,dy,dz = self.computeDirection(ob)
|
||||
location=(ob.matrixWorld*MATWORLD).translationPart()
|
||||
self.writeIndented("<%s\n" % obname,1)
|
||||
self.writeIndented("# direction %s %s %s\n" % (round(dx,3),round(dy,3),round(dz,3)))
|
||||
self.writeIndented("# location %s %s %s\n" % (round(location[0],3), round(location[1],3), round(location[2],3)))
|
||||
self.writeIndented("/>\n",-1)
|
||||
self.writeIndented("\n")
|
||||
|
||||
location=ob.getLocation('worldspace')
|
||||
radius = lamp.dist*math.cos(beamWidth)
|
||||
self.file.write("<SpotLight DEF=\"%s\" " % safeName)
|
||||
self.file.write("radius=\"%s\" " % (round(radius,self.cp)))
|
||||
self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity,self.cp)))
|
||||
self.file.write("intensity=\"%s\" " % (round(intensity,self.cp)))
|
||||
self.file.write("color=\"%s %s %s\" " % (round(lamp.col[0],self.cp), round(lamp.col[1],self.cp), round(lamp.col[2],self.cp)))
|
||||
self.file.write("beamWidth=\"%s\" " % (round(beamWidth,self.cp)))
|
||||
self.file.write("cutOffAngle=\"%s\" " % (round(cutOffAngle,self.cp)))
|
||||
self.file.write("direction=\"%s %s %s\" " % (round(dx,3),round(dy,3),round(dz,3)))
|
||||
self.file.write("location=\"%s %s %s\" />\n\n" % (round(location[0],3), round(location[1],3), round(location[2],3)))
|
||||
|
||||
def writeDirectionalLight(self, ob, lamp):
|
||||
safeName = self.cleanStr(ob.name)
|
||||
if world:
|
||||
ambi = world.amb
|
||||
ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2]))/3)/2.5
|
||||
else:
|
||||
ambi = 0
|
||||
ambientIntensity = 0
|
||||
def secureName(self, name):
|
||||
name = name + str(self.nodeID)
|
||||
self.nodeID=self.nodeID+1
|
||||
if len(name) <= 3:
|
||||
newname = "_" + str(self.nodeID)
|
||||
return "%s" % (newname)
|
||||
else:
|
||||
for bad in ['"','#',"'",',','.','[','\\',']','{','}']:
|
||||
name=name.replace(bad,'_')
|
||||
if name in self.namesReserved:
|
||||
newname = name[0:3] + "_" + str(self.nodeID)
|
||||
return "%s" % (newname)
|
||||
elif name[0].isdigit():
|
||||
newname = "_" + name + str(self.nodeID)
|
||||
return "%s" % (newname)
|
||||
else:
|
||||
newname = name
|
||||
return "%s" % (newname)
|
||||
|
||||
intensity=min(lamp.energy/1.75,1.0)
|
||||
(dx,dy,dz)=self.computeDirection(ob)
|
||||
self.file.write("<DirectionalLight DEF=\"%s\" " % safeName)
|
||||
self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity,self.cp)))
|
||||
self.file.write("color=\"%s %s %s\" " % (round(lamp.col[0],self.cp), round(lamp.col[1],self.cp), round(lamp.col[2],self.cp)))
|
||||
self.file.write("intensity=\"%s\" " % (round(intensity,self.cp)))
|
||||
self.file.write("direction=\"%s %s %s\" />\n\n" % (round(dx,4),round(dy,4),round(dz,4)))
|
||||
def writeIndexedFaceSet(self, ob, world, normals = 0):
|
||||
imageMap={} # set of used images
|
||||
sided={} # 'one':cnt , 'two':cnt
|
||||
vColors={} # 'multi':1
|
||||
meshName = self.cleanStr(ob.name)
|
||||
mesh=ob.getData(mesh=1)
|
||||
meshME = self.cleanStr(mesh.name)
|
||||
if len(mesh.faces) == 0: return
|
||||
mode = 0
|
||||
if mesh.faceUV:
|
||||
for face in mesh.faces:
|
||||
mode |= face.mode
|
||||
|
||||
if mode & Mesh.FaceModes.HALO and self.halonode == 0:
|
||||
self.writeIndented("<Billboard axisOfRotation=\"0 0 0\">\n",1)
|
||||
self.halonode = 1
|
||||
elif mode & Mesh.FaceModes.BILLBOARD and self.billnode == 0:
|
||||
self.writeIndented("<Billboard axisOfRotation=\"0 1 0\">\n",1)
|
||||
self.billnode = 1
|
||||
elif mode & Mesh.FaceModes.OBCOL and self.matonly == 0:
|
||||
self.matonly = 1
|
||||
elif mode & Mesh.FaceModes.TILES and self.tilenode == 0:
|
||||
self.tilenode = 1
|
||||
elif not mode & Mesh.FaceModes.DYNAMIC and self.collnode == 0:
|
||||
self.writeIndented("<Collision enabled=\"false\">\n",1)
|
||||
self.collnode = 1
|
||||
|
||||
def writePointLight(self, ob, lamp):
|
||||
safeName = self.cleanStr(ob.name)
|
||||
if world:
|
||||
ambi = world.amb
|
||||
ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2]))/3)/2.5
|
||||
else:
|
||||
ambi = 0
|
||||
ambientIntensity = 0
|
||||
|
||||
location=ob.getLocation('worldspace')
|
||||
intensity=min(lamp.energy/1.75,1.0)
|
||||
radius = lamp.dist
|
||||
self.file.write("<PointLight DEF=\"%s\" " % safeName)
|
||||
self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity,self.cp)))
|
||||
self.file.write("color=\"%s %s %s\" " % (round(lamp.col[0],self.cp), round(lamp.col[1],self.cp), round(lamp.col[2],self.cp)))
|
||||
self.file.write("intensity=\"%s\" " % (round(intensity,self.cp)))
|
||||
self.file.write("radius=\"%s\" " % radius )
|
||||
self.file.write("location=\"%s %s %s\" />\n\n" % (round(location[0],3), round(location[1],3), round(location[2],3)))
|
||||
nIFSCnt=self.countIFSSetsNeeded(mesh, imageMap, sided, vColors)
|
||||
|
||||
if nIFSCnt > 1:
|
||||
self.writeIndented("<Group DEF=\"%s%s\">\n" % ("G_", meshName),1)
|
||||
|
||||
if sided.has_key('two') and sided['two'] > 0:
|
||||
bTwoSided=1
|
||||
else:
|
||||
bTwoSided=0
|
||||
|
||||
def writeNode(self, thisObj):
|
||||
obname=str(thisObj.getName())
|
||||
if obname in self.namesStandard:
|
||||
return
|
||||
else:
|
||||
dx,dy,dz = self.computeDirection(thisObj)
|
||||
location = thisObj.getLocation('worldspace')
|
||||
self.writeIndented("<%s\n" % obname,1)
|
||||
self.writeIndented("# direction %s %s %s\n" % (round(dx,3),round(dy,3),round(dz,3)))
|
||||
self.writeIndented("# location %s %s %s\n" % (round(location[0],3), round(location[1],3), round(location[2],3)))
|
||||
self.writeIndented("/>\n",-1)
|
||||
self.writeIndented("\n")
|
||||
mtx = ob.matrixWorld * MATWORLD
|
||||
|
||||
loc= mtx.translationPart()
|
||||
sca= mtx.scalePart()
|
||||
quat = mtx.toQuat()
|
||||
rot= quat.axis
|
||||
|
||||
def secureName(self, name):
|
||||
name = name + str(self.nodeID)
|
||||
self.nodeID=self.nodeID+1
|
||||
if len(name) <= 3:
|
||||
newname = "_" + str(self.nodeID)
|
||||
return "%s" % (newname)
|
||||
else:
|
||||
for bad in ['"','#',"'",',','.','[','\\',']','{','}']:
|
||||
name=name.replace(bad,'_')
|
||||
if name in self.namesReserved:
|
||||
newname = name[0:3] + "_" + str(self.nodeID)
|
||||
return "%s" % (newname)
|
||||
elif name[0].isdigit():
|
||||
newname = "_" + name + str(self.nodeID)
|
||||
return "%s" % (newname)
|
||||
else:
|
||||
newname = name
|
||||
return "%s" % (newname)
|
||||
# self.writeIndented('<Transform rotation="%.6f %.6f %.6f %.6f">\n' % (rot[0], rot[1], rot[2], rot[3]))
|
||||
self.writeIndented('<Transform DEF="%s" translation="%.6f %.6f %.6f" scale="%.6f %.6f %.6f" rotation="%.6f %.6f %.6f %.6f">\n' % \
|
||||
(meshName, loc[0], loc[1], loc[2], sca[0], sca[1], sca[2], rot[0], rot[1], rot[2], quat.angle*DEG2RAD) )
|
||||
|
||||
def writeIndexedFaceSet(self, ob, normals = 0):
|
||||
imageMap={} # set of used images
|
||||
sided={} # 'one':cnt , 'two':cnt
|
||||
vColors={} # 'multi':1
|
||||
meshName = self.cleanStr(ob.name)
|
||||
mesh=ob.data
|
||||
meshME = self.cleanStr(mesh.name)
|
||||
if len(mesh.faces) == 0: return
|
||||
for face in mesh.faces:
|
||||
if face.mode & Blender.NMesh.FaceModes['HALO'] and self.halonode == 0:
|
||||
self.writeIndented("<Billboard axisOfRotation=\"0 0 0\">\n",1)
|
||||
self.halonode = 1
|
||||
elif face.mode & Blender.NMesh.FaceModes['BILLBOARD'] and self.billnode == 0:
|
||||
self.writeIndented("<Billboard axisOfRotation=\"0 1 0\">\n",1)
|
||||
self.billnode = 1
|
||||
elif face.mode & Blender.NMesh.FaceModes['OBCOL'] and self.matonly == 0:
|
||||
self.matonly = 1
|
||||
elif face.mode & Blender.NMesh.FaceModes['SHAREDCOL'] and self.share == 0:
|
||||
self.share = 1
|
||||
elif face.mode & Blender.NMesh.FaceModes['TILES'] and self.tilenode == 0:
|
||||
self.tilenode = 1
|
||||
elif not face.mode & Blender.NMesh.FaceModes['DYNAMIC'] and self.collnode == 0:
|
||||
self.writeIndented("<Collision enabled=\"false\">\n",1)
|
||||
self.collnode = 1
|
||||
self.writeIndented("<Shape>\n",1)
|
||||
maters=mesh.materials
|
||||
hasImageTexture=0
|
||||
issmooth=0
|
||||
|
||||
nIFSCnt=self.countIFSSetsNeeded(mesh, imageMap, sided, vColors)
|
||||
|
||||
if nIFSCnt > 1:
|
||||
self.writeIndented("<Group DEF=\"%s%s\">\n" % ("G_", meshName),1)
|
||||
|
||||
if sided.has_key('two') and sided['two'] > 0:
|
||||
bTwoSided=1
|
||||
else:
|
||||
bTwoSided=0
|
||||
|
||||
location= ob.getLocation('worldspace')
|
||||
self.writeIndented("<Transform DEF=\"%s\" translation=\"%s %s %s\">\n" % (meshName, round(location[0],3), round(location[1],3), round(location[2],3)),1)
|
||||
self.writeIndented("<Shape>\n",1)
|
||||
|
||||
maters=mesh.materials
|
||||
hasImageTexture=0
|
||||
issmooth=0
|
||||
if len(maters) > 0 or mesh.faceUV:
|
||||
self.writeIndented("<Appearance>\n", 1)
|
||||
# right now this script can only handle a single material per mesh.
|
||||
if len(maters) >= 1:
|
||||
mat=maters[0]
|
||||
matFlags = mat.getMode()
|
||||
if not matFlags & Blender.Material.Modes['TEXFACE']:
|
||||
self.writeMaterial(mat, self.cleanStr(maters[0].name,''), world)
|
||||
if len(maters) > 1:
|
||||
print "Warning: mesh named %s has multiple materials" % meshName
|
||||
print "Warning: only one material per object handled"
|
||||
|
||||
#-- textures
|
||||
if mesh.faceUV:
|
||||
for face in mesh.faces:
|
||||
if (hasImageTexture == 0) and (face.image):
|
||||
self.writeImageTexture(face.image)
|
||||
hasImageTexture=1 # keep track of face texture
|
||||
if self.tilenode == 1:
|
||||
self.writeIndented("<TextureTransform scale=\"%s %s\" />\n" % (face.image.xrep, face.image.yrep))
|
||||
self.tilenode = 0
|
||||
self.writeIndented("</Appearance>\n", -1)
|
||||
|
||||
if len(maters) > 0 or mesh.hasFaceUV():
|
||||
self.writeIndented("<Appearance>\n", 1)
|
||||
# right now this script can only handle a single material per mesh.
|
||||
if len(maters) >= 1:
|
||||
mat=maters[0]
|
||||
matFlags = mat.getMode()
|
||||
if not matFlags & Blender.Material.Modes['TEXFACE']:
|
||||
self.writeMaterial(mat, self.cleanStr(maters[0].name,''))
|
||||
if len(maters) > 1:
|
||||
print "Warning: mesh named %s has multiple materials" % meshName
|
||||
print "Warning: only one material per object handled"
|
||||
|
||||
#-- textures
|
||||
if mesh.hasFaceUV():
|
||||
for face in mesh.faces:
|
||||
if (hasImageTexture == 0) and (face.image):
|
||||
self.writeImageTexture(face.image)
|
||||
hasImageTexture=1 # keep track of face texture
|
||||
if self.tilenode == 1:
|
||||
self.writeIndented("<TextureTransform scale=\"%s %s\" />\n" % (face.image.xrep, face.image.yrep))
|
||||
self.tilenode = 0
|
||||
self.writeIndented("</Appearance>\n", -1)
|
||||
#-- IndexedFaceSet or IndexedLineSet
|
||||
|
||||
#-- IndexedFaceSet or IndexedLineSet
|
||||
# user selected BOUNDS=1, SOLID=3, SHARED=4, or TEXTURE=5
|
||||
ifStyle="IndexedFaceSet"
|
||||
# look up mesh name, use it if available
|
||||
if self.meshNames.has_key(meshME):
|
||||
self.writeIndented("<%s USE=\"ME_%s\">" % (ifStyle, meshME), 1)
|
||||
self.meshNames[meshME]+=1
|
||||
else:
|
||||
if int(mesh.users) > 1:
|
||||
self.writeIndented("<%s DEF=\"ME_%s\" " % (ifStyle, meshME), 1)
|
||||
self.meshNames[meshME]=1
|
||||
else:
|
||||
self.writeIndented("<%s " % ifStyle, 1)
|
||||
|
||||
if bTwoSided == 1:
|
||||
self.file.write("solid=\"false\" ")
|
||||
else:
|
||||
self.file.write("solid=\"true\" ")
|
||||
|
||||
# check if object is wireframe only
|
||||
if ob.drawType == Blender.Object.DrawTypes.WIRE:
|
||||
# user selected WIRE=2 on the Drawtype=Wire on (F9) Edit page
|
||||
ifStyle="IndexedLineSet"
|
||||
self.wire = 1
|
||||
else:
|
||||
# user selected BOUNDS=1, SOLID=3, SHARED=4, or TEXTURE=5
|
||||
ifStyle="IndexedFaceSet"
|
||||
# look up mesh name, use it if available
|
||||
if self.meshNames.has_key(meshME):
|
||||
self.writeIndented("<%s USE=\"ME_%s\">" % (ifStyle, meshME), 1)
|
||||
self.meshNames[meshME]+=1
|
||||
else:
|
||||
if int(mesh.users) > 1:
|
||||
self.writeIndented("<%s DEF=\"ME_%s\" " % (ifStyle, meshME), 1)
|
||||
self.meshNames[meshME]=1
|
||||
else:
|
||||
self.writeIndented("<%s " % ifStyle, 1)
|
||||
if ob.drawType != Blender.Object.DrawTypes.WIRE:
|
||||
if bTwoSided == 1:
|
||||
self.file.write("solid=\"false\" ")
|
||||
else:
|
||||
self.file.write("solid=\"true\" ")
|
||||
for face in mesh.faces:
|
||||
if face.smooth:
|
||||
issmooth=1
|
||||
break
|
||||
if issmooth==1:
|
||||
creaseAngle=(mesh.degr)*(math.pi/180.0)
|
||||
self.file.write("creaseAngle=\"%s\" " % (round(creaseAngle,self.cp)))
|
||||
|
||||
for face in mesh.faces:
|
||||
if face.smooth:
|
||||
issmooth=1
|
||||
break
|
||||
if issmooth==1 and self.wire == 0:
|
||||
creaseAngle=(mesh.getMaxSmoothAngle())*(math.pi/180.0)
|
||||
self.file.write("creaseAngle=\"%s\" " % (round(creaseAngle,self.cp)))
|
||||
#--- output textureCoordinates if UV texture used
|
||||
if mesh.faceUV:
|
||||
if self.matonly == 1 and self.share == 1:
|
||||
self.writeFaceColors(mesh)
|
||||
elif hasImageTexture == 1:
|
||||
self.writeTextureCoordinates(mesh)
|
||||
#--- output coordinates
|
||||
self.writeCoordinates(ob, mesh, meshName)
|
||||
|
||||
#--- output vertexColors
|
||||
if self.share == 1 and self.matonly == 0:
|
||||
self.writeVertexColors(mesh)
|
||||
if ob.drawType != Blender.Object.DrawTypes.WIRE:
|
||||
#--- output textureCoordinates if UV texture used
|
||||
if mesh.hasFaceUV():
|
||||
if self.matonly == 1 and self.share == 1:
|
||||
self.writeFaceColors(mesh)
|
||||
elif hasImageTexture == 1:
|
||||
self.writeTextureCoordinates(mesh)
|
||||
#--- output coordinates
|
||||
self.writeCoordinates(ob, mesh, meshName)
|
||||
self.writingcoords = 1
|
||||
self.writingtexture = 1
|
||||
self.writingcolor = 1
|
||||
self.writeCoordinates(ob, mesh, meshName)
|
||||
|
||||
#--- output textureCoordinates if UV texture used
|
||||
if mesh.faceUV:
|
||||
if hasImageTexture == 1:
|
||||
self.writeTextureCoordinates(mesh)
|
||||
elif self.matonly == 1 and self.share == 1:
|
||||
self.writeFaceColors(mesh)
|
||||
#--- output vertexColors
|
||||
self.matonly = 0
|
||||
self.share = 0
|
||||
|
||||
self.writingcoords = 0
|
||||
self.writingtexture = 0
|
||||
self.writingcolor = 0
|
||||
#--- output closing braces
|
||||
self.writeIndented("</%s>\n" % ifStyle, -1)
|
||||
self.writeIndented("</Shape>\n", -1)
|
||||
self.writeIndented("</Transform>\n", -1)
|
||||
|
||||
self.writingcoords = 1
|
||||
self.writingtexture = 1
|
||||
self.writingcolor = 1
|
||||
self.writeCoordinates(ob, mesh, meshName)
|
||||
|
||||
if ob.drawType != Blender.Object.DrawTypes.WIRE:
|
||||
#--- output textureCoordinates if UV texture used
|
||||
if mesh.hasFaceUV():
|
||||
if hasImageTexture == 1:
|
||||
self.writeTextureCoordinates(mesh)
|
||||
elif self.matonly == 1 and self.share == 1:
|
||||
self.writeFaceColors(mesh)
|
||||
#--- output vertexColors
|
||||
if self.share == 1 and self.matonly == 0:
|
||||
self.writeVertexColors(mesh)
|
||||
self.matonly = 0
|
||||
self.share = 0
|
||||
self.wire = 0
|
||||
self.writingcoords = 0
|
||||
self.writingtexture = 0
|
||||
self.writingcolor = 0
|
||||
#--- output closing braces
|
||||
self.writeIndented("</%s>\n" % ifStyle, -1)
|
||||
self.writeIndented("</Shape>\n", -1)
|
||||
self.writeIndented("</Transform>\n", -1)
|
||||
if self.halonode == 1:
|
||||
self.writeIndented("</Billboard>\n", -1)
|
||||
self.halonode = 0
|
||||
|
||||
if self.halonode == 1:
|
||||
self.writeIndented("</Billboard>\n", -1)
|
||||
self.halonode = 0
|
||||
if self.billnode == 1:
|
||||
self.writeIndented("</Billboard>\n", -1)
|
||||
self.billnode = 0
|
||||
|
||||
if self.billnode == 1:
|
||||
self.writeIndented("</Billboard>\n", -1)
|
||||
self.billnode = 0
|
||||
if self.collnode == 1:
|
||||
self.writeIndented("</Collision>\n", -1)
|
||||
self.collnode = 0
|
||||
|
||||
if self.collnode == 1:
|
||||
self.writeIndented("</Collision>\n", -1)
|
||||
self.collnode = 0
|
||||
if nIFSCnt > 1:
|
||||
self.writeIndented("</Group>\n", -1)
|
||||
|
||||
if nIFSCnt > 1:
|
||||
self.writeIndented("</Group>\n", -1)
|
||||
self.file.write("\n")
|
||||
|
||||
self.file.write("\n")
|
||||
def writeCoordinates(self, ob, mesh, meshName):
|
||||
# create vertex list and pre rotate -90 degrees X for VRML
|
||||
|
||||
if self.writingcoords == 0:
|
||||
self.file.write('coordIndex="')
|
||||
for face in mesh.faces:
|
||||
fv = face.v
|
||||
if len(face)==4:
|
||||
self.file.write("%i %i %i %i -1, " % (fv[0].index, fv[1].index, fv[2].index, fv[3].index))
|
||||
else:
|
||||
self.file.write("%i %i %i -1, " % (fv[0].index, fv[1].index, fv[2].index))
|
||||
self.file.write("\">\n")
|
||||
else:
|
||||
#-- vertices
|
||||
# mesh.transform(ob.matrixWorld)
|
||||
self.writeIndented("<Coordinate DEF=\"%s%s\" \n" % ("coord_",meshName), 1)
|
||||
self.file.write("\t\t\t\tpoint=\"")
|
||||
for v in mesh.verts:
|
||||
self.file.write("%.6f %.6f %.6f, " % tuple(v.co))
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n", -1)
|
||||
|
||||
def writeCoordinates(self, ob, mesh, meshName):
|
||||
meshVertexList = mesh.verts
|
||||
def writeTextureCoordinates(self, mesh):
|
||||
texCoordList=[]
|
||||
texIndexList=[]
|
||||
j=0
|
||||
|
||||
# create vertex list and pre rotate -90 degrees X for VRML
|
||||
location= ob.getLocation('worldspace')
|
||||
if self.writingcoords == 0:
|
||||
self.file.write('coordIndex="')
|
||||
for face in mesh.faces:
|
||||
for i in xrange(len(face)):
|
||||
indx=face[i].index
|
||||
self.file.write("%s " % indx)
|
||||
self.file.write("-1, ")
|
||||
self.file.write("\">\n")
|
||||
else:
|
||||
#-- vertices
|
||||
mesh.transform(ob.matrixWorld)
|
||||
self.writeIndented("<Coordinate DEF=\"%s%s\" \n" % ("coord_",meshName), 1)
|
||||
self.file.write("\t\t\t\tpoint=\"")
|
||||
for v in meshVertexList:
|
||||
self.file.write("%.6f %.6f %.6f, " % tuple(v.co))
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n", -1)
|
||||
for face in mesh.faces:
|
||||
for uv in face.uv:
|
||||
texIndexList.append(j)
|
||||
texCoordList.append(uv)
|
||||
j=j+1
|
||||
texIndexList.append(-1)
|
||||
if self.writingtexture == 0:
|
||||
self.file.write("\n\t\t\ttexCoordIndex=\"")
|
||||
texIndxStr=""
|
||||
for i in xrange(len(texIndexList)):
|
||||
texIndxStr = texIndxStr + "%d, " % texIndexList[i]
|
||||
if texIndexList[i]==-1:
|
||||
self.file.write(texIndxStr)
|
||||
texIndxStr=""
|
||||
self.file.write("\"\n\t\t\t")
|
||||
else:
|
||||
self.writeIndented("<TextureCoordinate point=\"", 1)
|
||||
for i in xrange(len(texCoordList)):
|
||||
self.file.write("%s %s, " % (round(texCoordList[i][0],self.tp), round(texCoordList[i][1],self.tp)))
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n", -1)
|
||||
|
||||
def writeTextureCoordinates(self, mesh):
|
||||
texCoordList=[]
|
||||
texIndexList=[]
|
||||
j=0
|
||||
def writeFaceColors(self, mesh):
|
||||
if self.writingcolor == 0:
|
||||
self.file.write("colorPerVertex=\"false\" ")
|
||||
else:
|
||||
self.writeIndented("<Color color=\"", 1)
|
||||
for face in mesh.faces:
|
||||
if face.col:
|
||||
c=face.col[0]
|
||||
if self.verbose > 2:
|
||||
print "Debug: face.col r=%d g=%d b=%d" % (c.r, c.g, c.b)
|
||||
aColor = self.rgbToFS(c)
|
||||
self.file.write("%s, " % aColor)
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n",-1)
|
||||
|
||||
def writeMaterial(self, mat, matName, world):
|
||||
# look up material name, use it if available
|
||||
if self.matNames.has_key(matName):
|
||||
self.writeIndented("<Material USE=\"MA_%s\" />\n" % matName)
|
||||
self.matNames[matName]+=1
|
||||
return;
|
||||
|
||||
for face in mesh.faces:
|
||||
for i in xrange(len(face)):
|
||||
texIndexList.append(j)
|
||||
texCoordList.append(face.uv[i])
|
||||
j=j+1
|
||||
texIndexList.append(-1)
|
||||
if self.writingtexture == 0:
|
||||
self.file.write("\n\t\t\ttexCoordIndex=\"")
|
||||
texIndxStr=""
|
||||
for i in xrange(len(texIndexList)):
|
||||
texIndxStr = texIndxStr + "%d, " % texIndexList[i]
|
||||
if texIndexList[i]==-1:
|
||||
self.file.write(texIndxStr)
|
||||
texIndxStr=""
|
||||
self.file.write("\"\n\t\t\t")
|
||||
else:
|
||||
self.writeIndented("<TextureCoordinate point=\"", 1)
|
||||
for i in xrange(len(texCoordList)):
|
||||
self.file.write("%s %s, " % (round(texCoordList[i][0],self.tp), round(texCoordList[i][1],self.tp)))
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n", -1)
|
||||
self.matNames[matName]=1
|
||||
|
||||
def writeFaceColors(self, mesh):
|
||||
if self.writingcolor == 0:
|
||||
self.file.write("colorPerVertex=\"false\" ")
|
||||
else:
|
||||
self.writeIndented("<Color color=\"", 1)
|
||||
for face in mesh.faces:
|
||||
if face.col:
|
||||
c=face.col[0]
|
||||
if self.verbose > 2:
|
||||
print "Debug: face.col r=%d g=%d b=%d" % (c.r, c.g, c.b)
|
||||
aColor = self.rgbToFS(c)
|
||||
self.file.write("%s, " % aColor)
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n",-1)
|
||||
ambient = mat.amb/3
|
||||
diffuseR, diffuseG, diffuseB = mat.rgbCol[0], mat.rgbCol[1],mat.rgbCol[2]
|
||||
if world:
|
||||
ambi = world.getAmb()
|
||||
ambi0, ambi1, ambi2 = (ambi[0]*mat.amb)*2, (ambi[1]*mat.amb)*2, (ambi[2]*mat.amb)*2
|
||||
else:
|
||||
ambi0, ambi1, ambi2 = 0, 0, 0
|
||||
emisR, emisG, emisB = (diffuseR*mat.emit+ambi0)/2, (diffuseG*mat.emit+ambi1)/2, (diffuseB*mat.emit+ambi2)/2
|
||||
|
||||
def writeVertexColors(self, mesh):
|
||||
if self.writingcolor == 0:
|
||||
self.file.write("colorPerVertex=\"false\" ")
|
||||
else:
|
||||
self.writeIndented("<Color color=\"", 1)
|
||||
for i in xrange(len(mesh.verts)):
|
||||
c=self.getVertexColorByIndx(mesh,i)
|
||||
if self.verbose > 2:
|
||||
print "Debug: vertex[%d].col r=%d g=%d b=%d" % (i, c.r, c.g, c.b)
|
||||
shininess = mat.hard/512.0
|
||||
specR = (mat.specCol[0]+0.001)/(1.25/(mat.spec+0.001))
|
||||
specG = (mat.specCol[1]+0.001)/(1.25/(mat.spec+0.001))
|
||||
specB = (mat.specCol[2]+0.001)/(1.25/(mat.spec+0.001))
|
||||
transp = 1-mat.alpha
|
||||
matFlags = mat.getMode()
|
||||
if matFlags & Blender.Material.Modes['SHADELESS']:
|
||||
ambient = 1
|
||||
shine = 1
|
||||
specR = emitR = diffuseR
|
||||
specG = emitG = diffuseG
|
||||
specB = emitB = diffuseB
|
||||
self.writeIndented("<Material DEF=\"MA_%s\" " % matName, 1)
|
||||
self.file.write("diffuseColor=\"%s %s %s\" " % (round(diffuseR,self.cp), round(diffuseG,self.cp), round(diffuseB,self.cp)))
|
||||
self.file.write("specularColor=\"%s %s %s\" " % (round(specR,self.cp), round(specG,self.cp), round(specB,self.cp)))
|
||||
self.file.write("emissiveColor=\"%s %s %s\" \n" % (round(emisR,self.cp), round(emisG,self.cp), round(emisB,self.cp)))
|
||||
self.writeIndented("ambientIntensity=\"%s\" " % (round(ambient,self.cp)))
|
||||
self.file.write("shininess=\"%s\" " % (round(shininess,self.cp)))
|
||||
self.file.write("transparency=\"%s\" />" % (round(transp,self.cp)))
|
||||
self.writeIndented("\n",-1)
|
||||
|
||||
aColor = self.rgbToFS(c)
|
||||
self.file.write("%s, " % aColor)
|
||||
self.file.write("\" />")
|
||||
self.writeIndented("\n",-1)
|
||||
def writeImageTexture(self, image):
|
||||
name = image.name
|
||||
filename = image.filename.split('/')[-1].split('\\')[-1]
|
||||
if self.texNames.has_key(name):
|
||||
self.writeIndented("<ImageTexture USE=\"%s\" />\n" % self.cleanStr(name))
|
||||
self.texNames[name] += 1
|
||||
return
|
||||
else:
|
||||
self.writeIndented("<ImageTexture DEF=\"%s\" " % self.cleanStr(name), 1)
|
||||
self.file.write("url=\"%s\" />" % name)
|
||||
self.writeIndented("\n",-1)
|
||||
self.texNames[name] = 1
|
||||
|
||||
def writeMaterial(self, mat, matName):
|
||||
# look up material name, use it if available
|
||||
if self.matNames.has_key(matName):
|
||||
self.writeIndented("<Material USE=\"MA_%s\" />\n" % matName)
|
||||
self.matNames[matName]+=1
|
||||
return;
|
||||
|
||||
self.matNames[matName]=1
|
||||
|
||||
ambient = mat.amb/3
|
||||
diffuseR, diffuseG, diffuseB = mat.rgbCol[0], mat.rgbCol[1],mat.rgbCol[2]
|
||||
if world:
|
||||
ambi = world.getAmb()
|
||||
ambi0, ambi1, ambi2 = (ambi[0]*mat.amb)*2, (ambi[1]*mat.amb)*2, (ambi[2]*mat.amb)*2
|
||||
else:
|
||||
ambi0, ambi1, ambi2 = 0, 0, 0
|
||||
emisR, emisG, emisB = (diffuseR*mat.emit+ambi0)/2, (diffuseG*mat.emit+ambi1)/2, (diffuseB*mat.emit+ambi2)/2
|
||||
|
||||
shininess = mat.hard/512.0
|
||||
specR = (mat.specCol[0]+0.001)/(1.25/(mat.getSpec()+0.001))
|
||||
specG = (mat.specCol[1]+0.001)/(1.25/(mat.getSpec()+0.001))
|
||||
specB = (mat.specCol[2]+0.001)/(1.25/(mat.getSpec()+0.001))
|
||||
transp = 1-mat.alpha
|
||||
matFlags = mat.getMode()
|
||||
if matFlags & Blender.Material.Modes['SHADELESS']:
|
||||
ambient = 1
|
||||
shine = 1
|
||||
specR = emitR = diffuseR
|
||||
specG = emitG = diffuseG
|
||||
specB = emitB = diffuseB
|
||||
self.writeIndented("<Material DEF=\"MA_%s\" " % matName, 1)
|
||||
self.file.write("diffuseColor=\"%s %s %s\" " % (round(diffuseR,self.cp), round(diffuseG,self.cp), round(diffuseB,self.cp)))
|
||||
self.file.write("specularColor=\"%s %s %s\" " % (round(specR,self.cp), round(specG,self.cp), round(specB,self.cp)))
|
||||
self.file.write("emissiveColor=\"%s %s %s\" \n" % (round(emisR,self.cp), round(emisG,self.cp), round(emisB,self.cp)))
|
||||
self.writeIndented("ambientIntensity=\"%s\" " % (round(ambient,self.cp)))
|
||||
self.file.write("shininess=\"%s\" " % (round(shininess,self.cp)))
|
||||
self.file.write("transparency=\"%s\" />" % (round(transp,self.cp)))
|
||||
self.writeIndented("\n",-1)
|
||||
|
||||
def writeImageTexture(self, image):
|
||||
name = image.name
|
||||
filename = image.filename.split('/')[-1].split('\\')[-1]
|
||||
if self.texNames.has_key(name):
|
||||
self.writeIndented("<ImageTexture USE=\"%s\" />\n" % self.cleanStr(name))
|
||||
self.texNames[name] += 1
|
||||
return
|
||||
else:
|
||||
self.writeIndented("<ImageTexture DEF=\"%s\" " % self.cleanStr(name), 1)
|
||||
self.file.write("url=\"%s\" />" % name)
|
||||
self.writeIndented("\n",-1)
|
||||
self.texNames[name] = 1
|
||||
|
||||
def writeBackground(self):
|
||||
if world: worldname = world.name
|
||||
else: return
|
||||
blending = world.getSkytype()
|
||||
grd = world.getHor()
|
||||
grd0, grd1, grd2 = grd[0], grd[1], grd[2]
|
||||
sky = world.getZen()
|
||||
sky0, sky1, sky2 = sky[0], sky[1], sky[2]
|
||||
mix0, mix1, mix2 = grd[0]+sky[0], grd[1]+sky[1], grd[2]+sky[2]
|
||||
mix0, mix1, mix2 = mix0/2, mix1/2, mix2/2
|
||||
self.file.write("<Background ")
|
||||
if worldname not in self.namesStandard:
|
||||
self.file.write("DEF=\"%s\" " % self.secureName(worldname))
|
||||
# No Skytype - just Hor color
|
||||
if blending == 0:
|
||||
self.file.write("groundColor=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
# Blend Gradient
|
||||
elif blending == 1:
|
||||
self.file.write("groundColor=\"%s %s %s, " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
# Blend+Real Gradient Inverse
|
||||
elif blending == 3:
|
||||
self.file.write("groundColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s, " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
# Paper - just Zen Color
|
||||
elif blending == 4:
|
||||
self.file.write("groundColor=\"%s %s %s\" " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s\" " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
# Blend+Real+Paper - komplex gradient
|
||||
elif blending == 7:
|
||||
self.writeIndented("groundColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.writeIndented("%s %s %s\" groundAngle=\"1.57, 1.57\" " %(round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.writeIndented("skyColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.writeIndented("%s %s %s\" skyAngle=\"1.57, 1.57\" " %(round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
# Any Other two colors
|
||||
else:
|
||||
self.file.write("groundColor=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s\" " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
alltexture = len(worldmat)
|
||||
for i in xrange(alltexture):
|
||||
namemat = worldmat[i].getName()
|
||||
pic = worldmat[i].getImage()
|
||||
if (namemat == "back") and (pic != None):
|
||||
self.file.write("\n\tbackUrl=\"%s\" " % str(pic.getName()))
|
||||
elif (namemat == "bottom") and (pic != None):
|
||||
self.writeIndented("bottomUrl=\"%s\" " % str(pic.getName()))
|
||||
elif (namemat == "front") and (pic != None):
|
||||
self.writeIndented("frontUrl=\"%s\" " % str(pic.getName()))
|
||||
elif (namemat == "left") and (pic != None):
|
||||
self.writeIndented("leftUrl=\"%s\" " % str(pic.getName()))
|
||||
elif (namemat == "right") and (pic != None):
|
||||
self.writeIndented("rightUrl=\"%s\" " % str(pic.getName()))
|
||||
elif (namemat == "top") and (pic != None):
|
||||
self.writeIndented("topUrl=\"%s\" " % str(pic.getName()))
|
||||
self.writeIndented("/>\n\n")
|
||||
def writeBackground(self, world, alltextures):
|
||||
if world: worldname = world.name
|
||||
else: return
|
||||
blending = world.getSkytype()
|
||||
grd = world.getHor()
|
||||
grd0, grd1, grd2 = grd[0], grd[1], grd[2]
|
||||
sky = world.getZen()
|
||||
sky0, sky1, sky2 = sky[0], sky[1], sky[2]
|
||||
mix0, mix1, mix2 = grd[0]+sky[0], grd[1]+sky[1], grd[2]+sky[2]
|
||||
mix0, mix1, mix2 = mix0/2, mix1/2, mix2/2
|
||||
self.file.write("<Background ")
|
||||
if worldname not in self.namesStandard:
|
||||
self.file.write("DEF=\"%s\" " % self.secureName(worldname))
|
||||
# No Skytype - just Hor color
|
||||
if blending == 0:
|
||||
self.file.write("groundColor=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
# Blend Gradient
|
||||
elif blending == 1:
|
||||
self.file.write("groundColor=\"%s %s %s, " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
# Blend+Real Gradient Inverse
|
||||
elif blending == 3:
|
||||
self.file.write("groundColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s, " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " %(round(mix0,self.cp), round(mix1,self.cp), round(mix2,self.cp)))
|
||||
# Paper - just Zen Color
|
||||
elif blending == 4:
|
||||
self.file.write("groundColor=\"%s %s %s\" " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s\" " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
# Blend+Real+Paper - komplex gradient
|
||||
elif blending == 7:
|
||||
self.writeIndented("groundColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.writeIndented("%s %s %s\" groundAngle=\"1.57, 1.57\" " %(round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.writeIndented("skyColor=\"%s %s %s, " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
self.writeIndented("%s %s %s\" skyAngle=\"1.57, 1.57\" " %(round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
# Any Other two colors
|
||||
else:
|
||||
self.file.write("groundColor=\"%s %s %s\" " % (round(grd0,self.cp), round(grd1,self.cp), round(grd2,self.cp)))
|
||||
self.file.write("skyColor=\"%s %s %s\" " % (round(sky0,self.cp), round(sky1,self.cp), round(sky2,self.cp)))
|
||||
alltexture = len(alltextures)
|
||||
for i in xrange(alltexture):
|
||||
namemat = alltextures[i].name
|
||||
pic = alltextures[i].getImage()
|
||||
if (namemat == "back") and (pic != None):
|
||||
self.file.write("\n\tbackUrl=\"%s\" " % pic.filename.split('/')[-1].split('\\')[-1])
|
||||
elif (namemat == "bottom") and (pic != None):
|
||||
self.writeIndented("bottomUrl=\"%s\" " % pic.filename.split('/')[-1].split('\\')[-1])
|
||||
elif (namemat == "front") and (pic != None):
|
||||
self.writeIndented("frontUrl=\"%s\" " % pic.filename.split('/')[-1].split('\\')[-1])
|
||||
elif (namemat == "left") and (pic != None):
|
||||
self.writeIndented("leftUrl=\"%s\" " % pic.filename.split('/')[-1].split('\\')[-1])
|
||||
elif (namemat == "right") and (pic != None):
|
||||
self.writeIndented("rightUrl=\"%s\" " % pic.filename.split('/')[-1].split('\\')[-1])
|
||||
elif (namemat == "top") and (pic != None):
|
||||
self.writeIndented("topUrl=\"%s\" " % pic.filename.split('/')[-1].split('\\')[-1])
|
||||
self.writeIndented("/>\n\n")
|
||||
|
||||
##########################################################
|
||||
# export routine
|
||||
##########################################################
|
||||
|
||||
def export(self, scene, world, worldmat):
|
||||
print "Info: starting X3D export to " + self.filename + "..."
|
||||
self.writeHeader()
|
||||
self.writeScript()
|
||||
self.writeNavigationInfo(scene)
|
||||
self.writeBackground()
|
||||
self.writeFog()
|
||||
self.proto = 0
|
||||
allObj = []
|
||||
if ARG == 'selected':
|
||||
allObj = list(scene.objects.context)
|
||||
else:
|
||||
allObj = list(scene.objects)
|
||||
self.writeInline()
|
||||
for thisObj in allObj:
|
||||
try:
|
||||
objType=thisObj.type
|
||||
objName=thisObj.name
|
||||
self.matonly = 0
|
||||
if objType == "Camera":
|
||||
self.writeViewpoint(thisObj)
|
||||
elif objType == "Mesh":
|
||||
self.writeIndexedFaceSet(thisObj, normals = 0)
|
||||
elif objType == "Lamp":
|
||||
lmpName= thisObj.data
|
||||
lmpType=lmpName.getType()
|
||||
if lmpType == Lamp.Types.Lamp:
|
||||
self.writePointLight(thisObj, lmpName)
|
||||
elif lmpType == Lamp.Types.Spot:
|
||||
self.writeSpotLight(thisObj, lmpName)
|
||||
elif lmpType == Lamp.Types.Sun:
|
||||
self.writeDirectionalLight(thisObj, lmpName)
|
||||
else:
|
||||
self.writeDirectionalLight(thisObj, lmpName)
|
||||
elif objType == "Empty" and objName != "Empty":
|
||||
self.writeNode(thisObj)
|
||||
else:
|
||||
#print "Info: Ignoring [%s], object type [%s] not handle yet" % (object.name,object.getType())
|
||||
print ""
|
||||
except AttributeError:
|
||||
print "Error: Unable to get type info for %s" % thisObj.getName()
|
||||
if ARG != 'selected':
|
||||
self.writeScript()
|
||||
self.file.write("\n</Scene>\n</X3D>")
|
||||
self.cleanup()
|
||||
|
||||
def export(self, scene, world, alltextures):
|
||||
print "Info: starting X3D export to " + self.filename + "..."
|
||||
self.writeHeader()
|
||||
self.writeScript()
|
||||
# self.writeNavigationInfo(scene) # This seems to position me in some strange area I cant see the model (with BS Contact) - Campbell
|
||||
self.writeBackground(world, alltextures)
|
||||
self.writeFog(world)
|
||||
self.proto = 0
|
||||
|
||||
for ob in scene.objects.context:
|
||||
objType=ob.type
|
||||
objName=ob.name
|
||||
self.matonly = 0
|
||||
if objType == "Camera":
|
||||
self.writeViewpoint(ob, scene)
|
||||
elif objType == "Mesh":
|
||||
self.writeIndexedFaceSet(ob, world, normals = 0)
|
||||
elif objType == "Lamp":
|
||||
data= ob.data
|
||||
datatype=data.type
|
||||
if datatype == Lamp.Types.Lamp:
|
||||
self.writePointLight(ob, data, world)
|
||||
elif datatype == Lamp.Types.Spot:
|
||||
self.writeSpotLight(ob, data, world)
|
||||
elif datatype == Lamp.Types.Sun:
|
||||
self.writeDirectionalLight(ob, data, world)
|
||||
else:
|
||||
self.writeDirectionalLight(ob, data, world)
|
||||
elif objType == "Empty" and objName != "Empty":
|
||||
self.writeNode(ob)
|
||||
else:
|
||||
#print "Info: Ignoring [%s], object type [%s] not handle yet" % (object.name,object.getType)
|
||||
print ""
|
||||
|
||||
if ARG != 'selected':
|
||||
self.writeScript()
|
||||
self.file.write("\n</Scene>\n</X3D>")
|
||||
self.cleanup()
|
||||
|
||||
##########################################################
|
||||
# Utility methods
|
||||
##########################################################
|
||||
|
||||
def cleanup(self):
|
||||
self.file.close()
|
||||
self.texNames={}
|
||||
self.matNames={}
|
||||
self.indentLevel=0
|
||||
print "Info: finished X3D export to %s\n" % self.filename
|
||||
def cleanup(self):
|
||||
self.file.close()
|
||||
self.texNames={}
|
||||
self.matNames={}
|
||||
self.indentLevel=0
|
||||
print "Info: finished X3D export to %s\n" % self.filename
|
||||
|
||||
def cleanStr(self, name, prefix='rsvd_'):
|
||||
"""cleanStr(name,prefix) - try to create a valid VRML DEF name from object name"""
|
||||
def cleanStr(self, name, prefix='rsvd_'):
|
||||
"""cleanStr(name,prefix) - try to create a valid VRML DEF name from object name"""
|
||||
|
||||
newName=name[:]
|
||||
if len(newName) == 0:
|
||||
self.nNodeID+=1
|
||||
return "%s%d" % (prefix, self.nNodeID)
|
||||
|
||||
if newName in self.namesReserved:
|
||||
newName='%s%s' % (prefix,newName)
|
||||
|
||||
if newName[0].isdigit():
|
||||
newName='%s%s' % ('_',newName)
|
||||
newName=name[:]
|
||||
if len(newName) == 0:
|
||||
self.nNodeID+=1
|
||||
return "%s%d" % (prefix, self.nNodeID)
|
||||
|
||||
if newName in self.namesReserved:
|
||||
newName='%s%s' % (prefix,newName)
|
||||
|
||||
if newName[0].isdigit():
|
||||
newName='%s%s' % ('_',newName)
|
||||
|
||||
for bad in [' ','"','#',"'",',','.','[','\\',']','{','}']:
|
||||
newName=newName.replace(bad,'_')
|
||||
return newName
|
||||
for bad in [' ','"','#',"'",',','.','[','\\',']','{','}']:
|
||||
newName=newName.replace(bad,'_')
|
||||
return newName
|
||||
|
||||
def countIFSSetsNeeded(self, mesh, imageMap, sided, vColors):
|
||||
"""
|
||||
countIFFSetsNeeded() - should look at a blender mesh to determine
|
||||
how many VRML IndexFaceSets or IndexLineSets are needed. A
|
||||
new mesh created under the following conditions:
|
||||
|
||||
o - split by UV Textures / one per mesh
|
||||
o - split by face, one sided and two sided
|
||||
o - split by smooth and flat faces
|
||||
o - split when faces only have 2 vertices * needs to be an IndexLineSet
|
||||
"""
|
||||
|
||||
imageNameMap={}
|
||||
faceMap={}
|
||||
nFaceIndx=0
|
||||
|
||||
for face in mesh.faces:
|
||||
sidename='';
|
||||
if (face.mode & NMesh.FaceModes.TWOSIDE) == NMesh.FaceModes.TWOSIDE:
|
||||
sidename='two'
|
||||
else:
|
||||
sidename='one'
|
||||
|
||||
if sided.has_key(sidename):
|
||||
sided[sidename]+=1
|
||||
else:
|
||||
sided[sidename]=1
|
||||
def countIFSSetsNeeded(self, mesh, imageMap, sided, vColors):
|
||||
"""
|
||||
countIFFSetsNeeded() - should look at a blender mesh to determine
|
||||
how many VRML IndexFaceSets or IndexLineSets are needed. A
|
||||
new mesh created under the following conditions:
|
||||
|
||||
o - split by UV Textures / one per mesh
|
||||
o - split by face, one sided and two sided
|
||||
o - split by smooth and flat faces
|
||||
o - split when faces only have 2 vertices * needs to be an IndexLineSet
|
||||
"""
|
||||
|
||||
imageNameMap={}
|
||||
faceMap={}
|
||||
nFaceIndx=0
|
||||
|
||||
if mesh.faceUV:
|
||||
for face in mesh.faces:
|
||||
sidename='';
|
||||
if face.mode & Mesh.FaceModes.TWOSIDE:
|
||||
sidename='two'
|
||||
else:
|
||||
sidename='one'
|
||||
|
||||
if sided.has_key(sidename):
|
||||
sided[sidename]+=1
|
||||
else:
|
||||
sided[sidename]=1
|
||||
|
||||
image = face.image
|
||||
if image:
|
||||
faceName="%s_%s" % (face.image.name, sidename);
|
||||
try:
|
||||
imageMap[faceName].append(face)
|
||||
except:
|
||||
imageMap[faceName]=[face.image.name,sidename,face]
|
||||
|
||||
if face.image:
|
||||
faceName="%s_%s" % (face.image.name, sidename);
|
||||
if self.verbose > 2:
|
||||
for faceName in imageMap.iterkeys():
|
||||
ifs=imageMap[faceName]
|
||||
print "Debug: faceName=%s image=%s, solid=%s facecnt=%d" % \
|
||||
(faceName, ifs[0], ifs[1], len(ifs)-2)
|
||||
|
||||
try:
|
||||
imageMap[faceName].append(face)
|
||||
except:
|
||||
imageMap[faceName]=[face.image.name,sidename,face]
|
||||
return len(imageMap)
|
||||
|
||||
def faceToString(self,face):
|
||||
|
||||
if self.verbose > 2:
|
||||
for faceName in imageMap.iterkeys():
|
||||
ifs=imageMap[faceName]
|
||||
print "Debug: faceName=%s image=%s, solid=%s facecnt=%d" % \
|
||||
(faceName, ifs[0], ifs[1], len(ifs)-2)
|
||||
print "Debug: face.flag=0x%x (bitflags)" % face.flag
|
||||
if face.sel:
|
||||
print "Debug: face.sel=true"
|
||||
|
||||
return len(imageMap)
|
||||
|
||||
def faceToString(self,face):
|
||||
print "Debug: face.mode=0x%x (bitflags)" % face.mode
|
||||
if face.mode & Mesh.FaceModes.TWOSIDE:
|
||||
print "Debug: face.mode twosided"
|
||||
|
||||
print "Debug: face.flag=0x%x (bitflags)" % face.flag
|
||||
if face.sel:
|
||||
print "Debug: face.sel=true"
|
||||
print "Debug: face.transp=0x%x (enum)" % face.transp
|
||||
if face.transp == Mesh.FaceTranspModes.SOLID:
|
||||
print "Debug: face.transp.SOLID"
|
||||
|
||||
print "Debug: face.mode=0x%x (bitflags)" % face.mode
|
||||
if (face.mode & NMesh.FaceModes.TWOSIDE) == NMesh.FaceModes.TWOSIDE:
|
||||
print "Debug: face.mode twosided"
|
||||
if face.image:
|
||||
print "Debug: face.image=%s" % face.image.name
|
||||
print "Debug: face.materialIndex=%d" % face.materialIndex
|
||||
|
||||
print "Debug: face.transp=0x%x (enum)" % face.transp
|
||||
if face.transp == NMesh.FaceTranspModes.SOLID:
|
||||
print "Debug: face.transp.SOLID"
|
||||
def getVertexColorByIndx(self, mesh, indx):
|
||||
c = None
|
||||
for face in mesh.faces:
|
||||
j=0
|
||||
for vertex in face.v:
|
||||
if vertex.index == indx:
|
||||
c=face.col[j]
|
||||
break
|
||||
j=j+1
|
||||
if c: break
|
||||
return c
|
||||
|
||||
if face.image:
|
||||
print "Debug: face.image=%s" % face.image.name
|
||||
print "Debug: face.materialIndex=%d" % face.materialIndex
|
||||
def meshToString(self,mesh):
|
||||
print "Debug: mesh.hasVertexUV=%d" % mesh.vertexColors
|
||||
print "Debug: mesh.faceUV=%d" % mesh.faceUV
|
||||
print "Debug: mesh.hasVertexColours=%d" % mesh.hasVertexColours()
|
||||
print "Debug: mesh.verts=%d" % len(mesh.verts)
|
||||
print "Debug: mesh.faces=%d" % len(mesh.faces)
|
||||
print "Debug: mesh.materials=%d" % len(mesh.materials)
|
||||
|
||||
def getVertexColorByIndx(self, mesh, indx):
|
||||
c = None
|
||||
for face in mesh.faces:
|
||||
j=0
|
||||
for vertex in face.v:
|
||||
if vertex.index == indx:
|
||||
c=face.col[j]
|
||||
break
|
||||
j=j+1
|
||||
if c: break
|
||||
return c
|
||||
def rgbToFS(self, c):
|
||||
s="%s %s %s" % (
|
||||
round(c.r/255.0,self.cp),
|
||||
round(c.g/255.0,self.cp),
|
||||
round(c.b/255.0,self.cp))
|
||||
return s
|
||||
|
||||
def meshToString(self,mesh):
|
||||
print "Debug: mesh.hasVertexUV=%d" % mesh.hasVertexUV()
|
||||
print "Debug: mesh.hasFaceUV=%d" % mesh.hasFaceUV()
|
||||
print "Debug: mesh.hasVertexColours=%d" % mesh.hasVertexColours()
|
||||
print "Debug: mesh.verts=%d" % len(mesh.verts)
|
||||
print "Debug: mesh.faces=%d" % len(mesh.faces)
|
||||
print "Debug: mesh.materials=%d" % len(mesh.materials)
|
||||
def computeDirection(self, ob):
|
||||
x,y,z=(0,-1.0,0) # point down
|
||||
|
||||
ax,ay,az = (ob.matrixWorld*MATWORLD).toEuler()
|
||||
|
||||
ax *= DEG2RAD
|
||||
ay *= DEG2RAD
|
||||
az *= DEG2RAD
|
||||
# rot X
|
||||
x1=x
|
||||
y1=y*math.cos(ax)-z*math.sin(ax)
|
||||
z1=y*math.sin(ax)+z*math.cos(ax)
|
||||
|
||||
def rgbToFS(self, c):
|
||||
s="%s %s %s" % (
|
||||
round(c.r/255.0,self.cp),
|
||||
round(c.g/255.0,self.cp),
|
||||
round(c.b/255.0,self.cp))
|
||||
return s
|
||||
# rot Y
|
||||
x2=x1*math.cos(ay)+z1*math.sin(ay)
|
||||
y2=y1
|
||||
z2=z1*math.cos(ay)-x1*math.sin(ay)
|
||||
|
||||
def computeDirection(self, ob):
|
||||
x,y,z=(0,-1.0,0) # point down
|
||||
ax,ay,az = (ob.RotX,ob.RotZ,ob.RotY)
|
||||
# rot Z
|
||||
x3=x2*math.cos(az)-y2*math.sin(az)
|
||||
y3=x2*math.sin(az)+y2*math.cos(az)
|
||||
z3=z2
|
||||
|
||||
# rot X
|
||||
x1=x
|
||||
y1=y*math.cos(ax)-z*math.sin(ax)
|
||||
z1=y*math.sin(ax)+z*math.cos(ax)
|
||||
return [x3,y3,z3]
|
||||
|
||||
|
||||
# rot Y
|
||||
x2=x1*math.cos(ay)+z1*math.sin(ay)
|
||||
y2=y1
|
||||
z2=z1*math.cos(ay)-x1*math.sin(ay)
|
||||
# swap Y and Z to handle axis difference between Blender and VRML
|
||||
#------------------------------------------------------------------------
|
||||
def rotatePointForVRML(self, v):
|
||||
x = v[0]
|
||||
y = v[2]
|
||||
z = -v[1]
|
||||
|
||||
vrmlPoint=[x, y, z]
|
||||
return vrmlPoint
|
||||
|
||||
# rot Z
|
||||
x3=x2*math.cos(az)-y2*math.sin(az)
|
||||
y3=x2*math.sin(az)+y2*math.cos(az)
|
||||
z3=z2
|
||||
# For writing well formed VRML code
|
||||
#------------------------------------------------------------------------
|
||||
def writeIndented(self, s, inc=0):
|
||||
if inc < 1:
|
||||
self.indentLevel = self.indentLevel + inc
|
||||
|
||||
return [x3,y3,z3]
|
||||
|
||||
spaces=""
|
||||
for x in xrange(self.indentLevel):
|
||||
spaces = spaces + "\t"
|
||||
self.file.write(spaces + s)
|
||||
|
||||
# swap Y and Z to handle axis difference between Blender and VRML
|
||||
#------------------------------------------------------------------------
|
||||
def rotatePointForVRML(self, v):
|
||||
x = v[0]
|
||||
y = v[2]
|
||||
z = -v[1]
|
||||
|
||||
vrmlPoint=[x, y, z]
|
||||
return vrmlPoint
|
||||
if inc > 0:
|
||||
self.indentLevel = self.indentLevel + inc
|
||||
|
||||
# For writing well formed VRML code
|
||||
#------------------------------------------------------------------------
|
||||
def writeIndented(self, s, inc=0):
|
||||
if inc < 1:
|
||||
self.indentLevel = self.indentLevel + inc
|
||||
# Converts a Euler to three new Quaternions
|
||||
# Angles of Euler are passed in as radians
|
||||
#------------------------------------------------------------------------
|
||||
def eulerToQuaternions(self, x, y, z):
|
||||
Qx = [math.cos(x/2), math.sin(x/2), 0, 0]
|
||||
Qy = [math.cos(y/2), 0, math.sin(y/2), 0]
|
||||
Qz = [math.cos(z/2), 0, 0, math.sin(z/2)]
|
||||
|
||||
quaternionVec=[Qx,Qy,Qz]
|
||||
return quaternionVec
|
||||
|
||||
# Multiply two Quaternions together to get a new Quaternion
|
||||
#------------------------------------------------------------------------
|
||||
def multiplyQuaternions(self, Q1, Q2):
|
||||
result = [((Q1[0] * Q2[0]) - (Q1[1] * Q2[1]) - (Q1[2] * Q2[2]) - (Q1[3] * Q2[3])),
|
||||
((Q1[0] * Q2[1]) + (Q1[1] * Q2[0]) + (Q1[2] * Q2[3]) - (Q1[3] * Q2[2])),
|
||||
((Q1[0] * Q2[2]) + (Q1[2] * Q2[0]) + (Q1[3] * Q2[1]) - (Q1[1] * Q2[3])),
|
||||
((Q1[0] * Q2[3]) + (Q1[3] * Q2[0]) + (Q1[1] * Q2[2]) - (Q1[2] * Q2[1]))]
|
||||
|
||||
return result
|
||||
|
||||
# Convert a Quaternion to an Angle Axis (ax, ay, az, angle)
|
||||
# angle is in radians
|
||||
#------------------------------------------------------------------------
|
||||
def quaternionToAngleAxis(self, Qf):
|
||||
scale = math.pow(Qf[1],2) + math.pow(Qf[2],2) + math.pow(Qf[3],2)
|
||||
ax = Qf[1]
|
||||
ay = Qf[2]
|
||||
az = Qf[3]
|
||||
|
||||
spaces=""
|
||||
for x in xrange(self.indentLevel):
|
||||
spaces = spaces + "\t"
|
||||
self.file.write(spaces + s)
|
||||
|
||||
if inc > 0:
|
||||
self.indentLevel = self.indentLevel + inc
|
||||
|
||||
# Converts a Euler to three new Quaternions
|
||||
# Angles of Euler are passed in as radians
|
||||
#------------------------------------------------------------------------
|
||||
def eulerToQuaternions(self, x, y, z):
|
||||
Qx = [math.cos(x/2), math.sin(x/2), 0, 0]
|
||||
Qy = [math.cos(y/2), 0, math.sin(y/2), 0]
|
||||
Qz = [math.cos(z/2), 0, 0, math.sin(z/2)]
|
||||
|
||||
quaternionVec=[Qx,Qy,Qz]
|
||||
return quaternionVec
|
||||
|
||||
# Multiply two Quaternions together to get a new Quaternion
|
||||
#------------------------------------------------------------------------
|
||||
def multiplyQuaternions(self, Q1, Q2):
|
||||
result = [((Q1[0] * Q2[0]) - (Q1[1] * Q2[1]) - (Q1[2] * Q2[2]) - (Q1[3] * Q2[3])),
|
||||
((Q1[0] * Q2[1]) + (Q1[1] * Q2[0]) + (Q1[2] * Q2[3]) - (Q1[3] * Q2[2])),
|
||||
((Q1[0] * Q2[2]) + (Q1[2] * Q2[0]) + (Q1[3] * Q2[1]) - (Q1[1] * Q2[3])),
|
||||
((Q1[0] * Q2[3]) + (Q1[3] * Q2[0]) + (Q1[1] * Q2[2]) - (Q1[2] * Q2[1]))]
|
||||
|
||||
return result
|
||||
|
||||
# Convert a Quaternion to an Angle Axis (ax, ay, az, angle)
|
||||
# angle is in radians
|
||||
#------------------------------------------------------------------------
|
||||
def quaternionToAngleAxis(self, Qf):
|
||||
scale = math.pow(Qf[1],2) + math.pow(Qf[2],2) + math.pow(Qf[3],2)
|
||||
ax = Qf[1]
|
||||
ay = Qf[2]
|
||||
az = Qf[3]
|
||||
|
||||
if scale > .0001:
|
||||
ax/=scale
|
||||
ay/=scale
|
||||
az/=scale
|
||||
|
||||
angle = 2 * math.acos(Qf[0])
|
||||
|
||||
result = [ax, ay, az, angle]
|
||||
return result
|
||||
if scale > .0001:
|
||||
ax/=scale
|
||||
ay/=scale
|
||||
az/=scale
|
||||
|
||||
angle = 2 * math.acos(Qf[0])
|
||||
|
||||
result = [ax, ay, az, angle]
|
||||
return result
|
||||
|
||||
##########################################################
|
||||
# Callbacks, needed before Main
|
||||
##########################################################
|
||||
|
||||
def select_file(filename):
|
||||
if not filename.endswith(extension):
|
||||
filename += extension
|
||||
if _safeOverwrite and sys.exists(filename):
|
||||
result = Draw.PupMenu("File Already Exists, Overwrite?%t|Yes%x1|No%x0")
|
||||
if(result != 1):
|
||||
return
|
||||
if not filename.endswith(extension):
|
||||
filename += extension
|
||||
#if _safeOverwrite and sys.exists(filename):
|
||||
# result = Draw.PupMenu("File Already Exists, Overwrite?%t|Yes%x1|No%x0")
|
||||
#if(result != 1):
|
||||
# return
|
||||
|
||||
scene = Blender.Scene.GetCurrent()
|
||||
world = scene.world
|
||||
alltextures = Blender.Texture.Get()
|
||||
|
||||
wrlexport=VRML2Export(filename)
|
||||
wrlexport.export(scene, world, worldmat)
|
||||
wrlexport=VRML2Export(filename)
|
||||
wrlexport.export(scene, world, alltextures)
|
||||
|
||||
def createWRLPath():
|
||||
filename = Blender.Get('filename')
|
||||
print filename
|
||||
|
||||
if filename.find('.') != -1:
|
||||
filename = filename.split('.')[0]
|
||||
filename += extension
|
||||
print filename
|
||||
|
||||
return filename
|
||||
|
||||
#########################################################
|
||||
# main routine
|
||||
#########################################################
|
||||
|
||||
try:
|
||||
ARG = __script__['arg'] # user selected argument
|
||||
except:
|
||||
print "older version"
|
||||
|
||||
if Blender.Get('version') < 235:
|
||||
print "Warning: X3D export failed, wrong blender version!"
|
||||
print " You aren't running blender version 2.35 or greater"
|
||||
print " download a newer version from http://blender3d.org/"
|
||||
else:
|
||||
if ARG == 'comp':
|
||||
from gzip import *
|
||||
extension=".x3dz"
|
||||
else:
|
||||
extension=".x3d"
|
||||
Blender.Window.FileSelector(select_file,"Export X3D",createWRLPath())
|
||||
|
||||
if __name__ == '__main__':
|
||||
Blender.Window.FileSelector(select_file,"Export X3D", Blender.Get('filename').replace('.blend', '.x3d'))
|
||||
# select_file('/shared/bed1.x3d')
|
||||
|
||||
Reference in New Issue
Block a user