kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
4b5203e29e
blender/release/scripts/wrl2export.py
Matt Ebb d34f89b755 * Edited and consistent-ified the File->Import menu item labels and fileselect button labels, as discussed on the forums. 
* Added items for importing DXF, VRML, etc. in the File->Import menu, that just call the normal Open function. Most people don't even know that you can open these formats through the normal Open fileselect, so this will make it more obvious.

* Removed the 'Export Selected' menu, and put poor old lonely STL in the Import and Export menus too. Most of the exporters export only the selected object anyway, so it's not really a necessary distinction to make.
2004-06-11 02:12:37 +00:00

986 lines
37 KiB
Python
Raw Blame History

#!BPY
""" Registration info for Blender menus:
Name: 'VRML 2.0 (.wrl)...'
Blender: 232
Group: 'Export'
Submenu: 'All Objects...' all
Submenu: 'Selected Objects...' selected
Tooltip: 'Export to VRML2 (.wrl) file.'
"""
# $Id$
#
#------------------------------------------------------------------------
# VRML2 exporter for blender 2.28a or above
#
# Source: http://blender.kimballsoftware.com/
#
# Authors: Rick Kimball with much inspiration
# from the forum at www.elysiun.com
# and irc://irc.freenode.net/blenderchat
# Ken Miller and Steve Matthews (Added Camera Support)
#
# ***** BEGIN GPL LICENSE BLOCK *****
#
# Copyright (C) 2003,2004: Rick Kimball rick@vrmlworld.net
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# ***** END GPL LICENCE BLOCK *****
#
# To use script:
# 1.) load this file in the text window.
# (press SHIFT+F11, Open New via Datablock button)
# 2.) make sure your mouse is over the text edit window and
# run this script. (press ALT+P)
# Or:
# copy to the scripts directory and it will appear in the
# export list. (Needs 2.32 or higher)
#
# Notes:
# a.) output filename is same as current blender file with .wrl extension
# b.) error messages go to the Blender DOS console window
#
# The latest version of this python export script:
# http://blender.kimballsoftware.com/
#
# If you like this script, try using http://vrmlworld.net/
# to show off your VRML world.
#
# 2004-01-19 by Rick Kimball <rick@vrmlworld.net>
# o added sub menus and file selector dialog
#
# 2004-01-17 by Rick Kimball <rick@vrmlworld.net>
# o add meta comments so script will appear in export menu list
#
# 2003-11-01 by Rick Kimball <rick@vrmlworld.net>
# o fixed issues related to Lamp object and 2.28a API.
#
# 2003-07-19 by Rick Kimball <rick@vrmlworld.net>
# o made compatible with new Python API in 2.28
#
# 2003-01-16 by Ken Miller - with math help from Steve Matthews :)
# o Added support for exporting cameras out of Blender
# o Sets the name of the camera as the object name
# o sets the description of the camera as the object name,
# which should be modified to something meaningful
# o sets the position and orientation
#
# 2003-01-19 Rick Kimball <rick@vrmlworld.net>
# o Added Support For PointLight, SpotLight and DirectionalLight using Lamps
# o Creates multi singlesided or doublesided IFS
# o Creates IndexedLineSets if DrawTypes is WIRE instead of Shaded
#
# 2003-02-03 Rick Kimball <rick@vrmlworld.net>
# o attempts to catch exceptions for empty objects
#
# 2003-02-04 Rick Kimball <rick@vrmlworld.net>
# o fixed file overwrite problem when blender filename is all uppercase
#
# 2003-02-08 Rick Kimball <rick@vrmlworld.net>
# o cleanStr() creates valid VRML DEF names even if object.name
# is zero length or uses VRML reserved names or characters
#
#------------------------------------------------------------------------
# Known Issue:
# o doesn't handle multiple materials (don't use material indices)
# o doesn't handle multiple UV textures on a single mesh. (create a mesh for each texture)
# o material colors need work
# o spotlight softness needs work
# o can't get the texture array associated with material * not the UV ones
# o can't set smoothing, crease angle and mesh smoothing * setting not accesible
#
# Still Todo:
#
# - Support for material indexes
# - Automatically Split IFS when multiple UV textures found * warning only now
# - Automatically Split IFS when combination of single vs double sided
# - Automatically Split IFS when face with only 2 vertices is found should be an ILS
# - Export common coordinate map for split IFS
# - Intelligent color array vs color index
# - Support more blender objects: World
# - Figure out how to output Animation
# - Add GUI to control the following:
# o All/Layer/Object output radio button
# o Color per vertex toggle yes/no
# o Complex/Simple VRML output radio button
# o Compressed/Uncompressed output radio button
# o Decimal precision dropdown 1,2,3,4,5,6
# o IFS/Elevation Grid output radio button
# o Normals output toggle yes/no
# o Proto output toggle yes/no
# o Verbose console progress
import Blender
from Blender import NMesh, Lamp
import math
#-- module constants
radD=math.pi/180.0
rad90=90.0*radD # for rotation
rad30=30.0*radD # default crease angle
ARG=''
#------------------------------------------------------------------------
#-- utility functions and classes --
#------------------------------------------------------------------------
def rad2deg(v):
return round(v*180.0/math.pi,4)
def deg2rad(v):
return (v*math.pi)/180.0;
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
#------------------------------------------------------
# the Blender.Object class seems to be missing this...
#------------------------------------------------------
if not hasattr(Blender.Object,'DrawTypes'):
Blender.Object.DrawTypes = DrawTypes()
#------------------------------------------------------------------------
#-- VRML2Export --
#------------------------------------------------------------------------
class VRML2Export:
#------------------------------------------------------------------------
def __init__(self, filename):
#--- public you can change these ---
self.verbose=1 # 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.ambientIntensity=.2
self.defCreaseAngle=rad30
self.smooth=0
#--- class private don't touch ---
self.texNames={} # dictionary of textureNames
self.matNames={} # dictionary of materiaNames
self.indentLevel=0 # keeps track of current indenting
self.filename=filename
self.file = open(filename, "w")
self.bNav=0
self.nNodeID=0
self.VRMLReserved=[ "Anchor","Appearance","Anchor","AudioClip","Background",
"Billboard", "Box", "Collision", "Color", "ColorInterpolator",
"Cone", "Coordinate", "CoordinateInterpolator", "Cylinder",
"CylinderSensor", "DirectionalLight", "ElevationGrid",
"Extrustion", "Fog", "FontStyle", "Group", "ImageTexture",
"IndexedFaceSet", "IndexedLineSet", "Inline", "LOD",
"Material", "MovieTexture", "NavigationInfo", "Normal",
"NormalInterpolator","OrientationInterpolator", "PixelTexture",
"PlaneSensor", "PointLight", "PointSet", "PositionInterpolator",
"ProxmimitySensor", "ScalarInterpolator", "Script", "Shape",
"Sound", "Sphere", "SphereSensor", "SpotLight", "Switch",
"Text", "TextureCoordinate", "TextureTransform", "TimeSensor",
"TouchSensor", "Transform", "Viewpoint", "VisibilitySensor",
"WorldInfo"
]
#------------------------------------------------------------------------
# writeHeader, export file, cleanup
#------------------------------------------------------------------------
def writeHeader(self):
self.file.write("#VRML V2.0 utf8\n")
self.file.write("# modeled using blender3d http://blender.org/$\n")
self.file.write("# exported using wrl2export.py version $Revision$\n")
self.file.write("# get latest exporter at http://kimballsoftware.com/blender/\n\n")
def export(self, scene):
print "Info: starting VRML2 export to " + self.filename + "..."
self.writeHeader()
theObjects = []
if ARG == 'selected':
theObjects = Blender.Object.GetSelected()
else:
theObjects = scene.getChildren()
for object in theObjects:
try:
objType=object.getType()
if objType == "Mesh":
self.writeIndexedFaceSet(object, normals = 0)
elif objType == "Camera":
self.writeCameraInfo(object)
elif objType == "Lamp":
# if there is a lamp then we probably want to turn off the headlight
if self.bNav == 0:
self.writeNavigationInfo()
self.bNav=1
#endif
lamp=Lamp.Get(object.data.getName())
try:
lampType=lamp.getType()
if lampType == Lamp.Types.Lamp:
self.writePointLight(object, lamp)
elif lampType == Lamp.Types.Spot:
self.writeSpotLight(object, lamp)
elif lampType == Lamp.Types.Sun:
self.writeDirectionalLight(object, lamp)
else:
self.writeDirectionalLight(object, lamp)
#endif
except AttributeError:
print "Error: Unable to get type info for %s" % object.name
else:
print "Info: Ignoring [%s], object type [%s] not handle yet" % \
(object.name,object.getType())
#endif
except ValueError:
print "Error: object named %s has problem with accessing an attribute" % object.name
#end try
#endfor
self.cleanup()
def cleanup(self):
self.file.close()
self.texNames={}
self.matNames={}
self.indentLevel=0
print "Info: finished VRML2 export to %s\n" % self.filename
#------------------------------------------------------------------------
# Writes out camera info as a viewpoint
# Handles orientation, position
# Use camera object name to set description
#------------------------------------------------------------------------
def writeCameraInfo(self, object):
if self.verbose > 0:
print "Info: exporting camera named="+object.name
#endif
self.writeIndented("DEF %s Viewpoint {\n" % (self.cleanStr(object.name)), 1)
self.writeIndented("description \"%s\" \n" % (object.name))
# get the camera location, subtract 90 degress from X to orient like VRML does
loc = self.rotatePointForVRML(object.loc)
rot = [object.RotX - 1.57, object.RotY, object.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)
# write orientation statement
self.writeIndented("orientation %3.2f %3.2f %3.2f %3.2f\n" %
(angleAxis[0], angleAxis[1], -angleAxis[2], angleAxis[3]))
# write position statement
self.writeIndented("position %3.2f %3.2f %3.2f\n" %
(loc[0], loc[1], loc[2]))
self.writeIndented("} # Viewpoint\n", -1)
self.writeIndented("\n")
#------------------------------------------------------------------------
def writeIndexedFaceSet(self, object, normals = 0):
if self.verbose > 0:
print "Info: exporting mesh named=["+object.name+"]"
#endif
imageMap={} # set of used images
sided={} # 'one':cnt , 'two':cnt
vColors={} # 'multi':1
mesh=object.getData()
nIFSCnt=self.countIFSSetsNeeded(mesh, imageMap, sided, vColors)
meshName = self.cleanStr(object.name)
if nIFSCnt > 1:
self.writeIndented("DEF %s%s Group {\n" % ("G_", meshName),1)
self.writeIndented("children [\n",1)
#endif
if self.verbose > 0:
print "Debug: [%s] has %d UV Textures" % (object.name, nIFSCnt)
#endif
if sided.has_key('two') and sided['two'] > 0:
bTwoSided=1
else:
bTwoSided=0
self.writeIndented("DEF %s Shape {\n" % meshName,1)
# show script debugging info
if self.verbose > 1:
self.meshToString(mesh)
print "Debug: mesh.faces["
for face in mesh.faces:
self.faceToString(face)
#endfor
print "Debug: ]"
#endif
maters=mesh.materials
hasImageTexture=0
if len(maters) > 0 or mesh.hasFaceUV():
self.writeIndented("appearance Appearance {\n", 1)
# right now this script can only handle a single material per mesh.
if len(maters) >= 1:
mat=Blender.Material.Get(maters[0].name)
self.writeMaterial(mat, self.cleanStr(maters[0].name,'mat_'))
if len(maters) > 1:
print "Warning: mesh named %s has multiple materials" % meshName
print "Warning: only one material per object handled"
#endif
else:
self.writeIndented("material NULL\n")
#endif
#-- textures
if mesh.hasFaceUV():
for face in mesh.faces:
if (hasImageTexture == 0) and (face.image):
self.writeImageTexture(face.image.name)
hasImageTexture=1 # keep track of face texture
#endif
#endfor
#endif
self.writeIndented("} # Appearance\n", -1)
#endif
#-------------------------------------------------------------------
#--
#-- IndexedFaceSet or IndexedLineSet
#
# check if object is wireframe only
if object.drawType == Blender.Object.DrawTypes.WIRE:
# user selected WIRE=2 on the Drawtype=Wire on (F9) Edit page
ifStyle="IndexedLineSet"
else:
# user selected BOUNDS=1, SOLID=3, SHARED=4, or TEXTURE=5
ifStyle="IndexedFaceSet"
#endif
self.writeIndented("geometry %s {\n" % ifStyle, 1)
if object.drawType != Blender.Object.DrawTypes.WIRE:
if bTwoSided == 1:
self.writeIndented("solid FALSE # two sided\n")
else:
self.writeIndented("solid TRUE # one sided\n")
#endif
#endif
#---
#--- output coordinates
self.writeCoordinates(object, mesh, meshName)
if object.drawType != Blender.Object.DrawTypes.WIRE:
#---
#--- output textureCoordinates if UV texture used
if mesh.hasFaceUV():
if hasImageTexture == 1:
self.writeTextureCoordinates(mesh)
if vColors.has_key('multi'):
self.writeVertexColors(mesh) # experiment
#endif
else:
self.writeFaceColors(mesh)
#endif hasImageTexture
#endif hasFaceUV
# TBD: figure out how to get this properly
if self.smooth:
creaseAngle=self.defCreaseAngle;
self.writeIndented("creaseAngle %s\n" % creaseAngle)
else:
self.writeIndented("creaseAngle 0.0 # in radians\n")
#endif mesh.smooth
#endif WIRE
#--- output vertexColors
if mesh.hasVertexColours() and vColors.has_key('multi'):
self.writeVertexColors(mesh)
#endif
#--- output closing braces
self.writeIndented("} # %s\n" % ifStyle, -1)
self.writeIndented("} # Shape\n", -1)
if nIFSCnt > 1:
self.writeIndented("] # children\n", -1)
self.writeIndented("} # Group\n", -1)
#endif
self.writeIndented("\n")
#------------------------------------------------------------------------
def writeCoordinates(self, object, mesh, meshName):
#-- vertices
self.writeIndented("coord DEF %s%s Coordinate {\n" % ("coord_",meshName), 1)
self.writeIndented("point [\n", 1)
meshVertexList = mesh.verts
# create vertex list and pre rotate -90 degrees X for VRML
mm=object.getMatrix()
for vertex in meshVertexList:
v=self.rotVertex(mm, vertex);
self.writeIndented("%s %s %s,\n" %
(round(v[0],self.vp),
round(v[1],self.vp),
round(v[2],self.vp) ))
#endfor
self.writeIndented("] # point\n", -1)
self.writeIndented("} # Coordinate\n", -1)
self.writeIndented("coordIndex [\n", 1)
coordIndexList=[]
for face in mesh.faces:
cordStr=""
for i in range(len(face)):
indx=meshVertexList.index(face[i])
cordStr = cordStr + "%s, " % indx
#endfor
self.writeIndented(cordStr + "-1,\n")
#endfor
self.writeIndented("] # coordIndex\n", -1)
#------------------------------------------------------------------------
def writeTextureCoordinates(self, mesh):
texCoordList=[]
texIndexList=[]
j=0
for face in mesh.faces:
for i in range(len(face)):
texIndexList.append(j)
texCoordList.append(face.uv[i])
j=j+1
#endfor
texIndexList.append(-1)
#endfor
self.writeIndented("texCoord TextureCoordinate {\n", 1)
self.writeIndented("point [\n", 1)
for i in range(len(texCoordList)):
self.writeIndented("%s %s," %
(round(texCoordList[i][0],self.tp),
round(texCoordList[i][1],self.tp))+"\n")
#endfor
self.writeIndented("] # point\n", -1)
self.writeIndented("} # texCoord\n", -1)
self.writeIndented("texCoordIndex [\n", 1)
texIndxStr=""
for i in range(len(texIndexList)):
texIndxStr = texIndxStr + "%d, " % texIndexList[i]
if texIndexList[i]==-1:
self.writeIndented(texIndxStr + "\n")
texIndxStr=""
#endif
#endfor
self.writeIndented("] # texCoordIndex\n", -1)
#------------------------------------------------------------------------
def writeFaceColors(self, mesh):
self.writeIndented("colorPerVertex FALSE\n")
self.writeIndented("color Color {\n",1)
self.writeIndented("color [\n",1)
for face in mesh.faces:
if face.col:
c=face.col[0]
if self.verbose > 1:
print "Debug: face.col r=%d g=%d b=%d" % (c.r, c.g, c.b)
#endif
aColor = self.rgbToFS(c)
self.writeIndented("%s,\n" % aColor)
#endfor
self.writeIndented("] # color\n",-1)
self.writeIndented("} # Color\n",-1)
#------------------------------------------------------------------------
def writeVertexColors(self, mesh):
self.writeIndented("colorPerVertex TRUE\n")
self.writeIndented("color Color {\n",1)
self.writeIndented("color [\n",1)
for i in range(len(mesh.verts)):
c=self.getVertexColorByIndx(mesh,i)
if self.verbose > 1:
print "Debug: vertex[%d].col r=%d g=%d b=%d" % (i, c.r, c.g, c.b)
#endif
aColor = self.rgbToFS(c)
self.writeIndented("%s,\n" % aColor)
#endfor
self.writeIndented("] # color\n",-1)
self.writeIndented("} # Color\n",-1)
#------------------------------------------------------------------------
def writeMaterial(self, mat, matName):
# look up material name, use it if available
if self.matNames.has_key(matName):
self.writeIndented("material USE %s\n" % matName)
self.matNames[matName]+=1
return;
#endif
self.matNames[matName]=1
ambient = mat.amb
diffuseR, diffuseG, diffuseB = mat.rgbCol[0], mat.rgbCol[1],mat.rgbCol[2]
emisR, emisG, emisB = diffuseR*mat.emit, diffuseG*mat.emit, diffuseB*mat.emit
shininess = mat.hard/255.0
specR = mat.specCol[0]
specG = mat.specCol[1]
specB = mat.specCol[2]
transp = 1-mat.alpha
self.writeIndented("material DEF %s Material {\n" % matName, 1)
self.writeIndented("diffuseColor %s %s %s" %
(round(diffuseR,self.cp), round(diffuseG,self.cp), round(diffuseB,self.cp)) +
"\n")
self.writeIndented("ambientIntensity %s" %
(round(ambient,self.cp))+
"\n")
self.writeIndented("specularColor %s %s %s" %
(round(specR,self.cp), round(specG,self.cp), round(specB,self.cp)) +
"\n" )
self.writeIndented("emissiveColor %s %s %s" %
(round(emisR,self.cp), round(emisG,self.cp), round(emisB,self.cp)) +
"\n" )
self.writeIndented("shininess %s" %
(round(shininess,self.cp)) +
"\n" )
self.writeIndented("transparency %s" %
(round(transp,self.cp)) +
"\n")
self.writeIndented("} # Material\n",-1)
#------------------------------------------------------------------------
def writeImageTexture(self, name):
if self.texNames.has_key(name):
self.writeIndented("texture USE %s\n" % self.cleanStr(name))
self.texNames[name] += 1
return
else:
self.writeIndented("texture DEF %s ImageTexture {\n" % self.cleanStr(name), 1)
self.writeIndented("url \"%s\"\n" % name)
self.writeIndented("} # ImageTexture \n",-1)
self.texNames[name] = 1
#endif
#------------------------------------------------------------------------
def writeSpotLight(self, object, lamp):
safeName = self.cleanStr(object.name)
# compute cutoff and beamwidth
intensity=min(lamp.energy/1.5,1.0) # TBD: figure out the right value
beamWidth=deg2rad(lamp.spotSize)*.5;
cutOffAngle=beamWidth*.99
(dx,dy,dz)=self.computeDirection(object)
# note -dx seems to equal om[3][0]
# note -dz seems to equal om[3][1]
# note dy seems to equal om[3][2]
om = object.getMatrix()
location=self.rotVertex(om, (0,0,0));
radius = lamp.dist*math.cos(beamWidth)
self.writeIndented("DEF %s SpotLight {\n" % safeName,1)
self.writeIndented("radius %s\n" % radius )
self.writeIndented("intensity %s\n" % intensity )
self.writeIndented("beamWidth %s # lamp.spotSize %s\n" % (beamWidth, lamp.spotSize) )
self.writeIndented("cutOffAngle %s # lamp.spotBlend %s\n" % (cutOffAngle, lamp.spotBlend))
self.writeIndented("direction %s %s %s # lamp.RotX=%s RotY=%s RotZ=%s\n" % \
(round(dx,3),round(dy,3),round(dz,3),
round(rad2deg(object.RotX),3),
round(rad2deg(object.RotY),3),
round(rad2deg(object.RotZ),3)))
self.writeIndented("location %s %s %s\n" % (round(location[0],3),
round(location[1],3),
round(location[2],3)))
self.writeIndented("} # SpotLight\n",-1)
# export a cone that matches the spotlight in verbose mode
if self.verbose > 1:
self.writeIndented("#generated visible spotlight cone\n")
self.writeIndented("Transform { # Spotlight Cone\n",1)
self.writeIndented("translation %s %s %s\n" % (round(location[0],3),
round(location[1],3),
round(location[2],3)))
rot = [object.RotX, object.RotY, object.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)
# write orientation statement
self.writeIndented("rotation %3.2f %3.2f %3.2f %3.2f\n" %
(angleAxis[0], angleAxis[1], -angleAxis[2], angleAxis[3]))
self.writeIndented("children [\n",1)
ch=radius
br=ch*math.sin(beamWidth)
self.writeIndented("Transform {\n",1)
self.writeIndented("translation 0 -%s 0\n" % (ch/2))
self.writeIndented("children ")
self.writeIndented("Collision {\n",1)
self.writeIndented("collide FALSE children Shape {\n",1)
self.writeIndented("geometry Cone { height %s bottomRadius %s }\n" % (ch, br))
self.writeIndented("appearance Appearance{\n",1)
self.writeIndented("material Material { diffuseColor 1 1 1 transparency .8 }\n")
self.writeIndented("} # Appearance\n",-1)
self.writeIndented("} # Shape\n",-1)
self.writeIndented("} # Collision\n",-1)
self.writeIndented("} # Transform visible cone \n",-1)
self.writeIndented("] # Spot children\n",-1)
self.writeIndented("} # SpotLight Cone Transform\n",-1)
#endif debug cone
self.writeIndented("\n")
#------------------------------------------------------------------------
def writeDirectionalLight(self, object, lamp):
safeName = self.cleanStr(object.name)
intensity=min(lamp.energy/1.5, 1.0) # TBD: figure out the right value
(dx,dy,dz)=self.computeDirection(object)
self.writeIndented("DEF %s DirectionalLight {\n" % safeName,1)
self.writeIndented("ambientIntensity %s\n" % self.ambientIntensity )
self.writeIndented("intensity %s\n" % intensity )
self.writeIndented("direction %s %s %s\n" % (round(dx,4),round(dy,4),round(dz,4)))
self.writeIndented("} # DirectionalLight\n",-1)
self.writeIndented("\n")
#------------------------------------------------------------------------
def writePointLight(self, object, lamp):
safeName = self.cleanStr(object.name)
om = object.getMatrix()
location=self.rotVertex(om, (0,0,0));
intensity=min(lamp.energy/1.5,1.0) # TBD: figure out the right value
radius = lamp.dist
self.writeIndented("DEF %s PointLight {\n" % safeName,1)
self.writeIndented("ambientIntensity %s\n" % self.ambientIntensity )
self.writeIndented("intensity %s\n" % intensity )
self.writeIndented("location %s %s %s\n" % (round(location[0],3),
round(location[1],3),
round(location[2],3)))
self.writeIndented("radius %s\n" % radius )
self.writeIndented("} # PointLight\n",-1)
self.writeIndented("\n")
#------------------------------------------------------------------------
def writeNavigationInfo(self):
self.writeIndented("NavigationInfo {\n",1)
self.writeIndented("headlight FALSE\n")
self.writeIndented("avatarSize [0.25, 1.75, 0.75]\n")
self.writeIndented("} # NavigationInfo\n",-1)
self.writeIndented("\n")
#------------------------------------------------------------------------
#--- Utility methods
#------------------------------------------------------------------------
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.VRMLReserved:
newName='%s%s' % (prefix,newName)
#endif
if newName[0] in ['0','1','2','3','4','5','6','7','8','9']:
newName='%s%s' % ('_',newName)
#endif
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'
#endif
if not vColors.has_key('multi'):
for face in mesh.faces:
if face.col:
c=face.col[0]
if c.r != 255 and c.g != 255 and c.b !=255:
vColors['multi']=1
#endif
#endif
#endfor
#endif
if sided.has_key(sidename):
sided[sidename]+=1
else:
sided[sidename]=1
#endif
if face.image:
faceName="%s_%s" % (face.image.name, sidename);
if imageMap.has_key(faceName):
imageMap[faceName].append(face)
else:
imageMap[faceName]=[face.image.name,sidename,face]
#endif
#endif
#endfor
if self.verbose > 0:
for faceName in imageMap.keys():
ifs=imageMap[faceName]
print "Debug: faceName=%s image=%s, solid=%s facecnt=%d" % \
(faceName, ifs[0], ifs[1], len(ifs)-2)
#endif
#endif
return len(imageMap.keys())
def faceToString(self,face):
print "Debug: face.flag=0x%x (bitflags)" % face.flag
if face.flag & NMesh.FaceFlags.SELECT == NMesh.FaceFlags.SELECT:
print "Debug: face.flag.SELECT=true"
#endif
print "Debug: face.mode=0x%x (bitflags)" % face.mode
if (face.mode & NMesh.FaceModes.TWOSIDE) == NMesh.FaceModes.TWOSIDE:
print "Debug: face.mode twosided"
#endif
print "Debug: face.transp=0x%x (enum)" % face.transp
if face.transp == NMesh.FaceTranspModes.SOLID:
print "Debug: face.transp.SOLID"
#
if face.image:
print "Debug: face.image=%s" % face.image.name
#endif
print "Debug: face.materialIndex=%d" % face.materialIndex
def getVertexColorByIndx(self, mesh, indx):
for face in mesh.faces:
j=0
for vertex in face.v:
if vertex.index == indx:
c=face.col[j]
#endif
j=j+1
#endfor
#endfor
return c
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 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 computeDirection(self, object):
x,y,z=(0,-1.0,0) # point down
ax,ay,az = (object.RotX,object.RotZ,object.RotY)
# rot X
x1=x
y1=y*math.cos(ax)-z*math.sin(ax)
z1=y*math.sin(ax)+z*math.cos(ax)
# rot Y
x2=x1*math.cos(ay)+z1*math.sin(ay)
y2=y1
z2=z1*math.cos(ay)-x1*math.sin(ay)
# rot Z
x3=x2*math.cos(az)-y2*math.sin(az)
y3=x2*math.sin(az)+y2*math.cos(az)
z3=z2
return [x3,y3,z3]
# 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
def rotVertex(self, mm, v):
lx,ly,lz=v[0],v[1],v[2]
gx=(mm[0][0]*lx + mm[1][0]*ly + mm[2][0]*lz) + mm[3][0]
gy=((mm[0][2]*lx + mm[1][2]*ly+ mm[2][2]*lz) + mm[3][2])
gz=-((mm[0][1]*lx + mm[1][1]*ly + mm[2][1]*lz) + mm[3][1])
rotatedv=[gx,gy,gz]
return rotatedv
def writeIndented(self, s, inc=0):
if inc < 1:
self.indentLevel = self.indentLevel + inc
#endif
spaces=""
for x in xrange(self.indentLevel):
spaces = spaces + " "
#endfor
self.file.write(spaces + s)
if inc > 0:
self.indentLevel = self.indentLevel + inc
#endif
# 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
#endif
angle = 2 * math.acos(Qf[0])
result = [ax, ay, az, angle]
return result
def file_callback(filename):
if filename.find('.wrl', -4) < 0: filename += '.wrl'
wrlexport=VRML2Export(filename)
scene = Blender.Scene.getCurrent()
wrlexport.export(scene)
#enddef
#------------------------------------------------------------------------
# main routine
#------------------------------------------------------------------------
try:
ARG = __script__['arg'] # user selected argument
except:
print "older version"
if Blender.Get('version') < 225:
print "Warning: VRML2 export failed, wrong blender version!"
print " You aren't running blender version 2.25 or greater"
print " download a newer version from http://blender.org/"
else:
if ARG == 'all' or ARG == 'selected':
Blender.Window.FileSelector(file_callback,"Export VRML 2.0")
else:
baseFileName=Blender.Get('filename')
if baseFileName.find('.') != -1:
dots=Blender.Get('filename').split('.')[0:-1]
else:
dots=[baseFileName]
#endif
dots+=["wrl"]
vrmlFile=".".join(dots)
file_callback(vrmlFile)
#endif
#endif
View Git Blame Copy Permalink