mirror of
https://github.com/Doodle3D/Doodle3D-Slicer.git
synced 2024-07-04 18:10:42 +02:00
1733 lines
33 KiB
Plaintext
Executable File
1733 lines
33 KiB
Plaintext
Executable File
rollout ThreeJSExporter "ThreeJSExporter"
|
|
(
|
|
-- Variables
|
|
|
|
local ostream,
|
|
|
|
threeMatrix = (matrix3 [1,0,0] [0,0,1] [0,-1,0] [0,0,0]),
|
|
|
|
headerFormat = "\"metadata\":
|
|
{
|
|
\"sourceFile\": \"%\",
|
|
\"generatedBy\": \"3ds max ThreeJSExporter\",
|
|
\"formatVersion\": 3,
|
|
\"vertices\": %,
|
|
\"normals\": %,
|
|
\"colors\": %,
|
|
\"uvs\": %,
|
|
\"triangles\": %,
|
|
\"materials\": %
|
|
},
|
|
|
|
",
|
|
|
|
vertexFormat = "%,%,%",
|
|
|
|
vertexNormalFormat = "%,%,%",
|
|
UVFormat = "%,%",
|
|
|
|
triFormat = "%,%,%,%",
|
|
triUVFormat = "%,%,%,%,%,%,%",
|
|
triNFormat = "%,%,%,%,%,%,%",
|
|
triUVNFormat = "%,%,%,%,%,%,%,%,%,%",
|
|
|
|
footerFormat = "\n}",
|
|
|
|
|
|
|
|
boneFormat = "\t\t{
|
|
\t\t\t\"parent\" : %,
|
|
\t\t\t\"name\" : \"%\",
|
|
\t\t\t\"pos\" : %,
|
|
\t\t\t\"scl\" : %,
|
|
\t\t\t\"rotq\" : [%,%,%,%]
|
|
\t\t}",
|
|
|
|
animHeaderFormat = "\t\"animation\" : {
|
|
\t\t\"name\" : \"Action\",
|
|
\t\t\"fps\" : %,
|
|
\t\t\"length\" : %,
|
|
\t\t\"hierarchy\" : [\n",
|
|
|
|
animBoneHeaderFormat = "\t\t\t{
|
|
\t\t\t\t\"parent\" : %,
|
|
\t\t\t\t\"keys\" : [\n",
|
|
|
|
keyFormat = "\t\t\t\t\t{
|
|
\t\t\t\t\t\t\"time\":%,
|
|
\t\t\t\t\t\t\"pos\" :[%,%,%],
|
|
\t\t\t\t\t\t\"rot\" :[%,%,%,%],
|
|
\t\t\t\t\t\t\"scl\" :%
|
|
\t\t\t\t\t}",
|
|
|
|
animBoneFooterFormat = "\t\t\t\t]
|
|
\t\t\t}",
|
|
|
|
animFooterFormat = "\n\n\t\t]
|
|
\t}\n"
|
|
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- User interface
|
|
|
|
|
|
group "ThreeJSExporter v0.8"
|
|
(
|
|
|
|
label msg "Exports selected meshes in Three.js ascii JSON format" align:#left
|
|
hyperLink lab1 "Original source at GitHub" address:"https://github.com/alteredq/three.js/blob/master/utils/exporters/max/ThreeJSExporter.ms" color:(color 255 120 0) align:#left
|
|
|
|
label dummy1 "--------------------------------------------------------" align:#left
|
|
|
|
checkbox exportColor "Export vertex colors" checked:false enabled:true
|
|
checkbox exportUv "Export uvs" checked:true enabled:true
|
|
checkbox exportNormal "Export normals" checked:true enabled:true
|
|
checkbox smoothNormal "Use vertex normals" checked:false enabled:true
|
|
|
|
label dummy2 "--------------------------------------------------------" align:#left
|
|
|
|
checkbox flipYZ "Flip YZ" checked:false enabled:false
|
|
checkbox flipUV "Flip UV" checked:false enabled:false
|
|
checkbox flipFace "Flip all faces" checked:false enabled:false
|
|
checkbox autoflipFace "Try fixing flipped faces" checked:false enabled:false
|
|
|
|
label dummy3 "--------------------------------------------------------" align:#left
|
|
|
|
spinner fps "Animation speed (FPS)" range:[0,1000,25] type:#integer
|
|
|
|
label dummy4 "--------------------------------------------------------" align:#left
|
|
|
|
button btn_export "Export selected objects"
|
|
|
|
)
|
|
|
|
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump vertices
|
|
|
|
function DumpVertices src =
|
|
(
|
|
|
|
Format "\"vertices\": [" to:ostream
|
|
|
|
num = src.count
|
|
|
|
if num > 0 then
|
|
(
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
vert = src[i]
|
|
|
|
if flipYZ.checked then
|
|
(
|
|
x = vert.x
|
|
y = vert.z
|
|
z = vert.y
|
|
|
|
z *= -1
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
x = vert.x
|
|
y = vert.y
|
|
z = vert.z
|
|
|
|
)
|
|
|
|
Format vertexFormat x y z to:ostream
|
|
|
|
if i < num then Format "," to:ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
Format "],\n\n" to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump colors
|
|
|
|
function DumpColors src useColors =
|
|
(
|
|
|
|
Format "\"colors\": [" to:ostream
|
|
|
|
num = src.count
|
|
|
|
if num > 0 and useColors then
|
|
(
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
col = src[i]
|
|
|
|
r = col.r as Integer
|
|
g = col.g as Integer
|
|
b = col.b as Integer
|
|
|
|
hexNum = ( bit.shift r 16 ) + ( bit.shift g 8 ) + b
|
|
|
|
-- hexColor = formattedPrint hexNum format:"#x"
|
|
-- Format "%" hexColor to:ostream
|
|
|
|
decColor = formattedPrint hexNum format:"#d"
|
|
Format "%" decColor to:ostream
|
|
|
|
if i < num then Format "," to:ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
Format "],\n\n" to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump normals
|
|
|
|
function DumpNormals src =
|
|
(
|
|
|
|
Format "\"normals\": [" to:ostream
|
|
|
|
num = src.count
|
|
|
|
if num > 0 and exportNormal.checked then
|
|
(
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
normal = src[i]
|
|
normal = normalize normal as point3
|
|
|
|
if flipYZ.checked then
|
|
(
|
|
|
|
x = normal.x
|
|
y = normal.z
|
|
z = normal.y
|
|
|
|
z *= -1
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
x = normal.x
|
|
y = normal.y
|
|
z = normal.z
|
|
|
|
)
|
|
|
|
Format vertexNormalFormat x y z to:ostream
|
|
|
|
if i < num then Format "," to:ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
Format "],\n\n" to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump uvs
|
|
|
|
function DumpUvs src =
|
|
(
|
|
|
|
Format "\"uvs\": [[" to:ostream
|
|
|
|
num = src.count
|
|
|
|
if num > 0 and exportUv.checked then
|
|
(
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
uvw = src[i]
|
|
|
|
u = uvw.x
|
|
|
|
if flipUV.checked then
|
|
(
|
|
v = 1 - uvw.y
|
|
)
|
|
else
|
|
(
|
|
v = uvw.y
|
|
)
|
|
|
|
Format UVFormat u v to:ostream
|
|
|
|
if i < num then Format "," to:ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
Format "]],\n\n" to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump faces
|
|
|
|
function DumpFaces src useColors =
|
|
(
|
|
|
|
Format "\"faces\": [" to:ostream
|
|
|
|
num = src.count
|
|
|
|
if num > 0 then
|
|
(
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
zface = src[i]
|
|
|
|
fv = zface[1]
|
|
fuv = zface[2]
|
|
m = zface[3] - 1
|
|
fc = zface[4]
|
|
|
|
needsFlip = zface[5]
|
|
|
|
isTriangle = true
|
|
hasMaterial = true
|
|
hasFaceUvs = false
|
|
hasFaceVertexUvs = ((classof fuv == Point3) and exportUv.checked)
|
|
hasFaceNormals = false
|
|
hasFaceVertexNormals = (exportNormal.checked)
|
|
hasFaceColors = false
|
|
hasFaceVertexColors = ((classof fc == Point3) and useColors)
|
|
|
|
faceType = 0
|
|
faceType = bit.set faceType 1 (not isTriangle)
|
|
faceType = bit.set faceType 2 hasMaterial
|
|
faceType = bit.set faceType 3 hasFaceUvs
|
|
faceType = bit.set faceType 4 hasFaceVertexUvs
|
|
faceType = bit.set faceType 5 hasFaceNormals
|
|
faceType = bit.set faceType 6 hasFaceVertexNormals
|
|
faceType = bit.set faceType 7 hasFaceColors
|
|
faceType = bit.set faceType 8 hasFaceVertexColors
|
|
|
|
if i > 1 then
|
|
(
|
|
Format "," faceType to:ostream
|
|
)
|
|
|
|
Format "%" faceType to:ostream
|
|
|
|
if isTriangle then
|
|
(
|
|
|
|
va = (fv.x - 1) as Integer
|
|
vb = (fv.y - 1) as Integer
|
|
vc = (fv.z - 1) as Integer
|
|
|
|
if flipFace.checked or needsFlip then
|
|
(
|
|
|
|
tmp = vb
|
|
vb = vc
|
|
vc = tmp
|
|
|
|
)
|
|
|
|
|
|
Format ",%,%,%" va vb vc to:ostream
|
|
|
|
|
|
if hasMaterial then
|
|
(
|
|
|
|
Format ",%" m to:ostream
|
|
|
|
)
|
|
|
|
if hasFaceVertexUvs then
|
|
(
|
|
|
|
ua = (fuv.x - 1) as Integer
|
|
ub = (fuv.y - 1) as Integer
|
|
uc = (fuv.z - 1) as Integer
|
|
|
|
if flipFace.checked or needsFlip then
|
|
(
|
|
|
|
tmp = ub
|
|
ub = uc
|
|
uc = tmp
|
|
|
|
)
|
|
|
|
Format ",%,%,%" ua ub uc to:ostream
|
|
|
|
)
|
|
|
|
if hasFaceVertexNormals then
|
|
(
|
|
|
|
if smoothNormal.checked then
|
|
(
|
|
|
|
-- normals have the same indices as vertices
|
|
|
|
na = va
|
|
nb = vb
|
|
nc = vc
|
|
|
|
)
|
|
else
|
|
(
|
|
-- normals have the same indices as face
|
|
|
|
na = i - 1
|
|
nb = na
|
|
nc = na
|
|
|
|
)
|
|
|
|
if flipFace.checked or needsFlip then
|
|
(
|
|
|
|
tmp = nb
|
|
nb = nc
|
|
nc = tmp
|
|
|
|
)
|
|
|
|
Format ",%,%,%" na nb nc to:ostream
|
|
|
|
)
|
|
|
|
|
|
if hasFaceVertexColors then
|
|
(
|
|
|
|
ca = (fc.x - 1) as Integer
|
|
cb = (fc.y - 1) as Integer
|
|
cc = (fc.z - 1) as Integer
|
|
|
|
if flipFace.checked or needsFlip then
|
|
(
|
|
|
|
tmp = cb
|
|
cb = cc
|
|
cc = tmp
|
|
|
|
)
|
|
|
|
Format ",%,%,%" ca cb cc to:ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
Format "]" to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump color
|
|
|
|
function DumpColor pcolor label =
|
|
(
|
|
r = pcolor.r / 255
|
|
g = pcolor.g / 255
|
|
b = pcolor.b / 255
|
|
|
|
fr = formattedPrint r format:".4f"
|
|
fg = formattedPrint g format:".4f"
|
|
fb = formattedPrint b format:".4f"
|
|
|
|
Format "\"%\" : [%, %, %],\n" label fr fg fb to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump map
|
|
|
|
function DumpMap pmap label =
|
|
(
|
|
|
|
if classof pmap == BitmapTexture then
|
|
(
|
|
bm = pmap.bitmap
|
|
|
|
if bm != undefined then
|
|
(
|
|
|
|
fname = filenameFromPath bm.filename
|
|
Format "\"%\" : \"skins/%\",\n" label fname to:ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump bones
|
|
-- src = #( #(index, name, position, scale, rotation), .. )
|
|
-- boneOrder lists the correct output order of the bones
|
|
-- newIndices is inverse of boneOrder
|
|
|
|
function DumpBones src boneOrder newIndices =
|
|
(
|
|
numBones = boneOrder.count
|
|
|
|
Format ",\n\n\t\"bones\" : [\n" to:ostream
|
|
|
|
for i = 1 to numBones do
|
|
(
|
|
b = src[boneOrder[i]]
|
|
if b[1] == -1 then
|
|
(
|
|
parent_index = -1
|
|
) else (
|
|
parent_index = newIndices[b[1]+1]
|
|
)
|
|
bone_name = b[2]
|
|
p = b[3]
|
|
s = b[4]
|
|
r = b[5]
|
|
|
|
Format boneFormat parent_index bone_name p s r.x r.y r.z r.w to:ostream
|
|
|
|
if (i < numBones) then (Format "," to:ostream)
|
|
Format "\n\n" to:ostream
|
|
)
|
|
Format "\t],\n\n" to:ostream
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump skin indices
|
|
-- src = #( #(skinned?, #(index1A, index1B, ..), name )
|
|
-- If the mesh wasn't skinned, look in boneNames for its parent to fix the index
|
|
-- If it's not there, leave as 0
|
|
-- boneOrder lists the correct output order of the bones
|
|
-- newIndices is inverse of boneOrder
|
|
|
|
function DumpIndices src boneNames newIndices =
|
|
(
|
|
output = #()
|
|
for i=1 to src.count do
|
|
(
|
|
if src[i][1] then
|
|
(
|
|
join output src[i][2]
|
|
) else (
|
|
bone = findItem boneNames src[i][3]
|
|
for j=1 to src[i][2].count do
|
|
(
|
|
src[i][2][j] = bone
|
|
)
|
|
join output src[i][2]
|
|
)
|
|
)
|
|
|
|
Format "\t\"skinIndices\" : [" to:ostream
|
|
num = output.count
|
|
|
|
if num > 0 then
|
|
(
|
|
for i = 1 to num do
|
|
(
|
|
Format "%" (newIndices[output[i] + 1]) to:ostream
|
|
if i < num then
|
|
(
|
|
Format "," to:ostream
|
|
)
|
|
)
|
|
)
|
|
|
|
Format "],\n\n" to:ostream
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump skin weights
|
|
-- src = #( weight1, weight2, .. )
|
|
|
|
function DumpWeights src =
|
|
(
|
|
Format "\t\"skinWeights\" : [" to:ostream
|
|
num = src.count
|
|
|
|
if num > 0 then
|
|
(
|
|
for i = 1 to num do
|
|
(
|
|
Format "%" src[i] to:ostream
|
|
if i < num then Format "," to:ostream
|
|
)
|
|
)
|
|
|
|
Format "],\n\n" to:ostream
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump the keyframes for every bone
|
|
-- src = #( #( parent, #( time, #( posx, posy, posz ), rot, scl ), .. ), .. )
|
|
-- ||---Bone-- |---------------Keyframe----------------| ----||
|
|
-- boneOrder lists the correct output order of the bones
|
|
-- newIndices is inverse of boneOrder
|
|
|
|
function DumpKeyframes src boneOrder newIndices fps =
|
|
(
|
|
Format animHeaderFormat fps src[1][2][src[1][2].count][1] to:ostream
|
|
|
|
numBones = boneOrder.count
|
|
|
|
for i = 1 to (numBones) do
|
|
(
|
|
if (src[boneOrder[i]][1] == -1) then
|
|
(
|
|
parent_index = -1
|
|
) else
|
|
(
|
|
parent_index = newIndices[src[boneOrder[i]][1]+1]
|
|
)
|
|
|
|
Format animBoneHeaderFormat parent_index to:ostream
|
|
|
|
bnkeys = src[boneOrder[i]][2]
|
|
|
|
for j = 1 to bnkeys.count do
|
|
(
|
|
Format keyFormat bnkeys[j][1] bnkeys[j][2][1] bnkeys[j][2][2] bnkeys[j][2][3] bnkeys[j][3].x bnkeys[j][3].y bnkeys[j][3].z bnkeys[j][3].w bnkeys[j][4] to:ostream
|
|
|
|
if j < bnkeys.count then Format "," to:ostream
|
|
Format "\n" to:ostream
|
|
)
|
|
|
|
Format animBoneFooterFormat to:ostream
|
|
|
|
if i < (numBones) then
|
|
(
|
|
Format "," to:ostream
|
|
)
|
|
Format "\n" to:ostream
|
|
)
|
|
|
|
Format animFooterFormat to:ostream
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Dump the morphtargets
|
|
-- src = #( #( #(index, name, vertices = #( #( x,y,z ), .. ) ), .. ), .. )
|
|
-- |List of meshes ----------------------------------------------|
|
|
-- |- |List of targets: only one mesh may have multiple ---| ----|
|
|
-- |- |- |Individual target(s) ----------------------| ----| ----|
|
|
|
|
function DumpMorphTargets src =
|
|
(
|
|
-- This procedure assumes that only one element of src has actual morph targets.
|
|
-- The targets field of the other elements is used to store the vertices of static meshes.
|
|
-- These vertices are duplicated and joined with the vertices of the actual morph targets.
|
|
|
|
-- Initialize with whatever happens to be first
|
|
|
|
output = src[1]
|
|
|
|
for m=2 to src.count do
|
|
(
|
|
|
|
if (src[m].count == 1) then
|
|
(
|
|
-- This is a static mesh; attach its vertices, but do nothing else.
|
|
|
|
for t=1 to output.count do
|
|
(
|
|
join output[t][3] src[m][1][3]
|
|
)
|
|
) else (
|
|
-- This mesh contains morph targets.
|
|
-- Duplicate the static vertices, join with each morph target, and set the indices and names.
|
|
|
|
while ( output.count < src[m].count ) do
|
|
(
|
|
-- Duplicate vertices
|
|
|
|
append output (deepCopy output[1])
|
|
)
|
|
|
|
for t=1 to src[m].count do
|
|
(
|
|
|
|
-- Vertices
|
|
join output[t][3] src[m][t][3]
|
|
|
|
-- Index, name
|
|
output[t][1] = src[m][t][1]
|
|
output[t][2] = src[m][t][2]
|
|
|
|
)
|
|
)
|
|
)
|
|
|
|
Format "\"morphTargets\": [" to:ostream
|
|
|
|
for k=1 to output.count do
|
|
(
|
|
target = output[k]
|
|
|
|
Format "{ \"name\": \"morph_%\", \"vertices\": [" target[2] to:ostream
|
|
|
|
vertices = target[3]
|
|
|
|
for j=1 to vertices.count do
|
|
(
|
|
Format "%,%,%" vertices[j][1] vertices[j][2] vertices[j][3] to:ostream
|
|
if (j != vertices.count) then
|
|
(
|
|
Format "," to:ostream
|
|
)
|
|
)
|
|
|
|
Format "] }" to:ostream
|
|
if (k != output.count) then
|
|
(
|
|
Format ",\n" to:ostream
|
|
)
|
|
)
|
|
|
|
Format "],\n" to:ostream
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Export materials
|
|
|
|
function ExportMaterials zmaterials zcolors =
|
|
(
|
|
|
|
Format "\"materials\": [\n" to:ostream
|
|
|
|
totalMaterials = zmaterials.count
|
|
|
|
for i = 1 to totalMaterials do
|
|
(
|
|
mat = zmaterials[i]
|
|
|
|
Format "{\n" to:ostream
|
|
|
|
-- debug
|
|
|
|
Format "\"DbgIndex\" : %,\n" (i-1) to:ostream
|
|
|
|
if classof mat != BooleanClass then
|
|
(
|
|
|
|
useVertexColors = zcolors[i]
|
|
|
|
Format "\"DbgName\" : \"%\",\n" mat.name to:ostream
|
|
|
|
-- colors
|
|
|
|
DumpColor mat.diffuse "colorDiffuse"
|
|
DumpColor mat.ambient "colorAmbient"
|
|
DumpColor mat.specular "colorSpecular"
|
|
|
|
t = mat.opacity / 100
|
|
s = mat.glossiness
|
|
|
|
Format "\"transparency\" : %,\n" t to:ostream
|
|
Format "\"specularCoef\" : %,\n" s to:ostream
|
|
|
|
-- maps
|
|
|
|
DumpMap mat.diffuseMap "mapDiffuse"
|
|
DumpMap mat.ambientMap "mapAmbient"
|
|
DumpMap mat.specularMap "mapSpecular"
|
|
DumpMap mat.bumpMap "mapBump"
|
|
DumpMap mat.opacityMap "mapAlpha"
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
useVertexColors = false
|
|
|
|
Format "\"DbgName\" : \"%\",\n" "dummy" to:ostream
|
|
|
|
DumpColor red "colorDiffuse"
|
|
|
|
)
|
|
|
|
Format "\"vertexColors\" : %\n" useVertexColors to:ostream
|
|
Format "}" to:ostream
|
|
|
|
if ( i < totalMaterials ) then Format "," to:ostream
|
|
Format "\n\n" to:ostream
|
|
|
|
)
|
|
|
|
Format "],\n\n" to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract vertices from mesh
|
|
|
|
function ExtractVertices obj whereto =
|
|
(
|
|
|
|
n = obj.numVerts
|
|
|
|
for i = 1 to n do
|
|
(
|
|
|
|
v = GetVert obj i
|
|
append whereto v
|
|
|
|
)
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract vertex colors from mesh
|
|
|
|
function ExtractColors obj whereto =
|
|
(
|
|
|
|
nColors = GetNumCPVVerts obj
|
|
|
|
if nColors > 0 then
|
|
(
|
|
|
|
for i = 1 to nColors do
|
|
(
|
|
|
|
c = GetVertColor obj i
|
|
append whereto c
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract normals from mesh
|
|
|
|
function ExtractNormals obj whereto needsFlip =
|
|
(
|
|
|
|
if smoothNormal.checked then
|
|
(
|
|
|
|
num = obj.numVerts
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
n = GetNormal obj i
|
|
|
|
if flipFace.checked or needsFlip then
|
|
(
|
|
n.x *= -1
|
|
n.y *= -1
|
|
n.z *= -1
|
|
)
|
|
|
|
append whereto n
|
|
|
|
)
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
num = obj.numFaces
|
|
|
|
for i = 1 to num do
|
|
(
|
|
|
|
n = GetFaceNormal obj i
|
|
|
|
if flipFace.checked or needsFlip then
|
|
(
|
|
n.x *= -1
|
|
n.y *= -1
|
|
n.z *= -1
|
|
)
|
|
|
|
append whereto n
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract uvs from mesh
|
|
|
|
function ExtractUvs obj whereto =
|
|
(
|
|
n = obj.numTVerts
|
|
|
|
for i = 1 to n do
|
|
(
|
|
|
|
v = GetTVert obj i
|
|
append whereto v
|
|
|
|
)
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract faces from mesh
|
|
|
|
function ExtractFaces objMesh objMaterial whereto allMaterials needsFlip hasVColors offsetVert offsetUv offsetColor =
|
|
(
|
|
n = objMesh.numFaces
|
|
hasUVs = objMesh.numTVerts > 0
|
|
|
|
useMultiMaterial = false
|
|
materialIDList = #()
|
|
|
|
materialClass = classof objMaterial
|
|
|
|
if materialClass == StandardMaterial then
|
|
(
|
|
|
|
fm = findItem allMaterials objMaterial
|
|
|
|
)
|
|
else if materialClass == MultiMaterial then
|
|
(
|
|
|
|
useMultiMaterial = true
|
|
|
|
for i = 1 to n do
|
|
(
|
|
|
|
mID = GetFaceMatID objMesh i
|
|
materialIndex = findItem objMaterial.materialIDList mID
|
|
|
|
if materialIndex > 0 then
|
|
(
|
|
|
|
subMaterial = objMaterial.materialList[materialIndex]
|
|
|
|
mMergedIndex = findItem allMaterials subMaterial
|
|
|
|
if mMergedIndex > 0 then
|
|
(
|
|
|
|
materialIDList[mID] = mMergedIndex
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
materialIDList[mID] = findItem allMaterials false
|
|
|
|
)
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
materialIDList[mID] = findItem allMaterials false
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
-- undefined material
|
|
|
|
fm = findItem allMaterials false
|
|
|
|
)
|
|
|
|
for i = 1 to n do
|
|
(
|
|
|
|
zface = #()
|
|
|
|
fv = GetFace objMesh i
|
|
|
|
fv.x += offsetVert
|
|
fv.y += offsetVert
|
|
fv.z += offsetVert
|
|
|
|
if useMultiMaterial then
|
|
(
|
|
|
|
mID = GetFaceMatID objMesh i
|
|
fm = materialIDList[mID]
|
|
|
|
)
|
|
|
|
if hasUVs then
|
|
(
|
|
|
|
fuv = GetTVFace objMesh i
|
|
|
|
fuv.x += offsetUv
|
|
fuv.y += offsetUv
|
|
fuv.z += offsetUv
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
fuv = false
|
|
|
|
)
|
|
|
|
if hasVColors then
|
|
(
|
|
|
|
fc = GetVCFace objMesh i
|
|
|
|
fc.x += offsetColor
|
|
fc.y += offsetColor
|
|
fc.z += offsetColor
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
fc = false
|
|
|
|
)
|
|
|
|
append zface fv
|
|
append zface fuv
|
|
append zface fm
|
|
append zface fc
|
|
append zface needsFlip
|
|
|
|
append whereto zface
|
|
|
|
)
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract materials from eventual multi-material
|
|
|
|
function ExtractMaterials objMesh objMaterial whereto wheretoColors zname hasVColors =
|
|
(
|
|
|
|
materialClass = classof objMaterial
|
|
|
|
if materialClass == StandardMaterial then
|
|
(
|
|
|
|
if ( findItem whereto objMaterial ) == 0 then
|
|
(
|
|
|
|
append whereto objMaterial
|
|
append wheretoColors hasVColors
|
|
|
|
)
|
|
|
|
)
|
|
else if materialClass == MultiMaterial then
|
|
(
|
|
|
|
n = objMesh.numFaces
|
|
|
|
for i = 1 to n do
|
|
(
|
|
|
|
mID = getFaceMatId objMesh i
|
|
materialIndex = findItem objMaterial.materialIDList mID
|
|
|
|
if materialIndex > 0 then
|
|
(
|
|
|
|
subMaterial = objMaterial.materialList[materialIndex]
|
|
|
|
if ( findItem whereto subMaterial ) == 0 then
|
|
(
|
|
|
|
append whereto subMaterial
|
|
append wheretoColors hasVColors
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
else
|
|
(
|
|
|
|
-- unknown or undefined material
|
|
|
|
append whereto false
|
|
append wheretoColors false
|
|
|
|
)
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Hack to figure out if normals are messed up
|
|
|
|
function NeedsFaceFlip node =
|
|
(
|
|
needsFlip = false
|
|
|
|
local tmp = Snapshot node
|
|
|
|
face_normal = normalize ( getfacenormal tmp 1 )
|
|
|
|
face = getface tmp 1
|
|
|
|
va = getvert tmp face[1]
|
|
vb = getvert tmp face[2]
|
|
vc = getvert tmp face[3]
|
|
|
|
computed_normal = normalize ( cross (vc - vb) (va - vb) )
|
|
|
|
if distance computed_normal face_normal > 0.1 then needsFlip = true
|
|
|
|
delete tmp
|
|
|
|
return needsFlip
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract only things that either already are or can be converted to meshes
|
|
|
|
function ExtractMesh node =
|
|
(
|
|
|
|
if SuperClassOf node == GeometryClass then
|
|
(
|
|
needsFlip = false
|
|
hasVColors = false
|
|
|
|
zmesh = SnapshotAsMesh node
|
|
|
|
if autoflipFace.checked then
|
|
(
|
|
|
|
needsFlip = NeedsFaceFlip node
|
|
|
|
)
|
|
|
|
if exportColor.checked and ( getNumCPVVerts zmesh ) > 0 then
|
|
(
|
|
|
|
hasVColors = true
|
|
|
|
)
|
|
|
|
return #( zmesh, node.name, node.material, needsFlip, hasVColors )
|
|
|
|
)
|
|
|
|
-- Not geometry ... could be a camera, light, etc.
|
|
|
|
return #( false, node.name, 0, false, false )
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract the morph targets
|
|
-- whereto = #( #( #(index, name, vertices = #( #( x,y,z ), .. ) ), .. ), .. )
|
|
-- |List of meshes -----------------------------------------------|
|
|
-- |- |List of targets -------------------------------------| ----|
|
|
-- |- |- |Individual target --------------------------| ----| ----|
|
|
|
|
function ExtractMorphTargets node whereto &morphFlag =
|
|
(
|
|
targets = #()
|
|
morphs = #()
|
|
|
|
if ( node.modifiers[#morpher] != undefined ) then (
|
|
-- Export the morph target, if one exists
|
|
|
|
morphFlag = true
|
|
|
|
for i=1 to 100 do
|
|
(
|
|
nPts = WM3_MC_NumMPts node.morpher i
|
|
if (nPts > 0) then
|
|
(
|
|
append targets #(i, nPts)
|
|
)
|
|
)
|
|
|
|
--Set all to zero
|
|
for k=1 to targets.count do
|
|
(
|
|
i = targets[k][1]
|
|
node.morpher[i].controller.value = 0
|
|
)
|
|
|
|
--Max out one at a time, record it, then zero out again
|
|
for k=1 to targets.count do
|
|
(
|
|
i = targets[k][1]
|
|
numVerts = targets[k][2]
|
|
name = WM3_MC_GetName node.morpher i
|
|
verts = #()
|
|
|
|
node.morpher[i].controller.value = 100
|
|
|
|
for j = 1 to numVerts do
|
|
(
|
|
p = GetVert node j
|
|
append verts #(p.x, p.y, p.z)
|
|
)
|
|
|
|
node.morpher[i].controller.value = 0
|
|
|
|
append morphs #(i, name, verts)
|
|
)
|
|
append whereto morphs
|
|
) else (
|
|
-- Export the mesh vertices as a dummy morph target
|
|
|
|
verts = #()
|
|
for k=1 to node.numVerts do
|
|
(
|
|
p = GetVert node k
|
|
append verts #(p.x, p.y, p.z)
|
|
)
|
|
|
|
dummy = #()
|
|
append dummy #(0, "DUMMY", verts)
|
|
append whereto dummy
|
|
)
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Transforms the matrix of a bone into its parent space, if a parent exists.
|
|
|
|
function thinkLocally bone_node localForm =
|
|
(
|
|
localForm = bone_node.transform
|
|
|
|
if ( bone_node.parent != undefined ) then
|
|
(
|
|
parentForm = bone_node.parent.transform
|
|
localForm = localForm * inverse parentForm
|
|
)
|
|
|
|
newLocal = matrix3 1
|
|
|
|
px = localForm.translationpart.x
|
|
py = localForm.translationpart.y
|
|
pz = localForm.translationpart.z
|
|
lTran = transMatrix (localForm.translationpart)
|
|
|
|
lRot = (inverse localForm.rotationpart) as matrix3
|
|
|
|
lScale = scaleMatrix localForm.scalepart
|
|
|
|
localForm = lScale * lRot * lTran * newLocal
|
|
|
|
localForm
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract bones and keyframes
|
|
|
|
function ExtractAnimation node bones keyframes FPS bone_names &skinFlag =
|
|
(
|
|
if node.modifiers[#skin] != undefined then
|
|
(
|
|
skinFlag = true
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- A dummy root bone is first created and roatated to orient the model
|
|
|
|
p = (matrix3 1).translationpart
|
|
s = (matrix3 1).scalepart
|
|
r = (matrix3 1).rotationpart
|
|
|
|
append bones #(-1,"flipRoot",p,s,r)
|
|
|
|
/*
|
|
if (flipYZ.checked) then
|
|
(
|
|
r = threeMatrix.rotationpart
|
|
) else (
|
|
r = (matrix3 1).rotationpart
|
|
)
|
|
*/
|
|
|
|
r = threeMatrix.rotationpart
|
|
|
|
root_keys = #(#(0, p, r, s))
|
|
|
|
slidertime = 0
|
|
|
|
while (slidertime < animationrange.end) do
|
|
(
|
|
slidertime += 1
|
|
sTime = (slidertime / FPS) as String
|
|
|
|
append root_keys #(substring sTime 1 (sTime.count - 1), p, r, s)
|
|
)
|
|
|
|
append keyframes #(-1, root_keys)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- The model's bones and keyframes are then extracted
|
|
|
|
max modify mode
|
|
|
|
total_bones = skinops.getnumberbones node.modifiers[#skin]
|
|
|
|
vertex_count = getNumverts node
|
|
|
|
-- Find parents by looking up their names; bone names MUST be unique
|
|
-- Can't guarantee that parent will be read before child; store all names beforehand
|
|
for i = 1 to total_bones do
|
|
(
|
|
bone_name = skinops.getbonename node.modifiers[#skin] i 0
|
|
append bone_names bone_name
|
|
)
|
|
|
|
for i = 1 to total_bones do
|
|
(
|
|
slidertime = 0
|
|
|
|
bone_name = skinops.getbonename node.modifiers[#skin] i 0
|
|
bone_node = getNodeByName bone_name
|
|
|
|
parent_index = 0
|
|
if ( bone_node.parent != undefined ) then
|
|
(
|
|
parent_name = bone_node.parent.name
|
|
parent_index = (findItem bone_names parent_name)
|
|
)
|
|
|
|
localForm = bone_node.transform
|
|
localForm = thinkLocally bone_node localForm
|
|
|
|
p = localForm.translationpart
|
|
r = localForm.rotationpart
|
|
s = localForm.scalepart
|
|
|
|
append bones #(parent_index, bone_name, p, bone_node.transform.scalepart, r)
|
|
|
|
in coordsys parent bone_keys = #(#(0, p, r, bone_node.transform.scalepart))
|
|
|
|
while (slidertime < animationrange.end) do
|
|
(
|
|
slidertime += 1
|
|
sTime = (slidertime / FPS) as String
|
|
|
|
localForm = bone_node.transform
|
|
localForm = thinkLocally bone_node localForm
|
|
|
|
p = localForm.translationpart
|
|
r = localForm.rotationpart
|
|
s = localForm.translationpart
|
|
|
|
append bone_keys #(substring sTime 1 (sTime.count - 1), p, r, bone_node.transform.scalepart)
|
|
)
|
|
append keyframes #(parent_index, bone_keys)
|
|
)
|
|
)
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Extract the skin indices and weights in one pass
|
|
-- If it's a skin, skinned? = true and indices contains the bones
|
|
-- If it's not, indices is dummied to #(0,..) and DumpIndices uses the parent to fix it in post
|
|
-- indices = #( #( skinned?, indices, parent), ..)
|
|
|
|
function ExtractInfluences node indices weights =
|
|
(
|
|
vertex_count = getNumverts node
|
|
|
|
meshIndices = #()
|
|
|
|
if node.modifiers[#skin] != undefined then
|
|
(
|
|
|
|
for i = 1 to vertex_count do
|
|
(
|
|
-- Insane defaults for the sort; these shouldn't escape into the output
|
|
index1 = -1
|
|
index2 = -1
|
|
weight1 = -1
|
|
weight2 = -1
|
|
|
|
numBones = skinOps.GetVertexWeightCount node.modifiers[#skin] i
|
|
|
|
--Two passes of a bubble sort to get the 2 heaviest weights
|
|
for j = 1 to numBones do
|
|
(
|
|
thisIndex = skinops.getVertexWeightBoneID node.modifiers[#skin] i j
|
|
thisWeight = skinops.getvertexweight node.modifiers[#skin] i j
|
|
|
|
if (thisWeight) > weight1 then
|
|
(
|
|
weight1 = thisWeight
|
|
index1 = thisIndex
|
|
)
|
|
)
|
|
|
|
for j = 1 to numBones do
|
|
(
|
|
thisIndex = skinops.getVertexWeightBoneID node.modifiers[#skin] i j
|
|
thisWeight = skinops.getvertexweight node.modifiers[#skin] i j
|
|
|
|
if ((thisWeight > weight2) and (thisIndex != index1)) then
|
|
(
|
|
weight2 = thisWeight
|
|
index2 = thisIndex
|
|
)
|
|
)
|
|
|
|
-- Establish legal defaults: no weight from the root
|
|
if (index1 == -1) then
|
|
(
|
|
index1 = 0
|
|
weight1 = 0
|
|
)
|
|
if (index2 == -1) then
|
|
(
|
|
index2 = 0
|
|
weight2 = 0
|
|
)
|
|
|
|
|
|
append meshIndices (index1)
|
|
append meshIndices (index2)
|
|
|
|
append weights weight1
|
|
append weights weight2
|
|
|
|
)
|
|
|
|
append indices #(true, meshIndices, "ROOT")
|
|
|
|
) else (
|
|
for i = 1 to vertex_count do
|
|
(
|
|
append meshIndices 0
|
|
append meshIndices 0
|
|
|
|
append weights 1
|
|
append weights 1
|
|
)
|
|
|
|
name = "Scene Root"
|
|
if node.parent != undefined then
|
|
(
|
|
name = node.parent.name
|
|
)
|
|
|
|
append indices #(false, meshIndices, name)
|
|
)
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Enforce that parent is above all of its children in the output
|
|
-- This fixes several amusing bugs (mostly fingers of infinite length)
|
|
--
|
|
-- boneOrder: order to dump the bones in #(bones)
|
|
-- newIndices: new positional indices of bones
|
|
|
|
function ReorderBones bones boneOrder newIndices =
|
|
(
|
|
|
|
/*************************************************************************************
|
|
* Reorder bones
|
|
* Python function prototype:
|
|
* for i in range(n):
|
|
* for b in range(n):
|
|
* #new bone parent of bone legal
|
|
* if not inOut[b] and (parents[b] == -1 or inOut[parents[b]]):
|
|
* inOut[b] = True
|
|
* boneOrder.append(b)
|
|
* break;
|
|
*************************************************************************************/
|
|
|
|
total_bones = bones.count
|
|
|
|
-- Keeps track of which parents have been accounted for
|
|
inOut = #()
|
|
|
|
for i = 1 to total_bones do
|
|
(
|
|
append inOut false
|
|
)
|
|
|
|
rootNotAdded = true
|
|
for i = 1 to total_bones do
|
|
(
|
|
|
|
notFound = true
|
|
for b = 1 to total_bones while notFound do
|
|
(
|
|
if (inOut[b] != true) then
|
|
(
|
|
if (rootNotAdded and bones[b][1] == -1) then
|
|
(
|
|
inOut[b] = true
|
|
append boneOrder b
|
|
notFound = false
|
|
rootNotAdded = false
|
|
) else (
|
|
if (inOut[bones[b][1] + 1]) then
|
|
(
|
|
inOut[b] = true
|
|
append boneOrder b
|
|
notFound = false
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
)
|
|
|
|
-- Takes original bone index/parent + 1, returns new correct index for parent, skinIndices, etc
|
|
for i=1 to total_bones do
|
|
(
|
|
newIndices[boneOrder[i]] = i - 1
|
|
)
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Export scene
|
|
--
|
|
-- This will BREAK in HORRIBLE WAYS if you feed it more than one object for now.
|
|
|
|
function ExportScene =
|
|
(
|
|
|
|
-- Extract meshes
|
|
|
|
meshObjects = #()
|
|
|
|
mergedVertices = #()
|
|
mergedNormals = #()
|
|
mergedColors = #()
|
|
|
|
mergedUvs = #()
|
|
mergedFaces = #()
|
|
|
|
mergedMaterials = #()
|
|
mergedMaterialsColors = #()
|
|
|
|
sceneHasVColors = false
|
|
|
|
hasSkin = false
|
|
bones = #()
|
|
keyframes = #()
|
|
|
|
influences = #()
|
|
weights = #()
|
|
|
|
boneOrder = #()
|
|
newIndices = #()
|
|
bone_names = #()
|
|
|
|
hasMorph = false
|
|
mergedMorphTargets = #()
|
|
|
|
-- The horrible hackery that is skinops requires only one object be selected.
|
|
original_selection = #()
|
|
for obj in selection do
|
|
(
|
|
append original_selection obj.name
|
|
)
|
|
|
|
max select none
|
|
|
|
for name in original_selection do
|
|
(
|
|
obj = getnodebyname name
|
|
select obj
|
|
|
|
result = ExtractMesh obj
|
|
meshObj = result[1]
|
|
|
|
if ClassOf meshObj == TriMesh then
|
|
(
|
|
|
|
meshName = result[2]
|
|
meshMaterial = result[3]
|
|
needsFlip = result[4]
|
|
hasVColors = result[5]
|
|
|
|
sceneHasVColors = sceneHasVColors or hasVColors
|
|
|
|
append meshObjects result
|
|
|
|
vertexOffset = mergedVertices.count
|
|
uvOffset = mergedUvs.count
|
|
colorOffset = mergedColors.count
|
|
|
|
ExtractMaterials meshObj meshMaterial mergedMaterials mergedMaterialsColors meshName hasVColors
|
|
|
|
ExtractVertices meshObj mergedVertices
|
|
ExtractNormals meshObj mergedNormals needsFlip
|
|
ExtractColors meshObj mergedColors
|
|
|
|
ExtractUvs meshObj mergedUvs
|
|
|
|
ExtractFaces meshObj meshMaterial mergedFaces mergedMaterials needsFlip hasVColors vertexOffset uvOffset colorOffset
|
|
|
|
ExtractAnimation obj bones keyframes fps.value bone_names &hasSkin
|
|
|
|
ExtractInfluences obj influences weights
|
|
|
|
ReorderBones bones boneOrder newIndices
|
|
|
|
ExtractMorphTargets obj mergedMorphTargets &hasMorph
|
|
|
|
)
|
|
|
|
max select none
|
|
)
|
|
|
|
totalVertices = mergedVertices.count
|
|
totalFaces = mergedFaces.count
|
|
totalMaterials = mergedMaterials.count
|
|
|
|
totalColors = 0
|
|
totalNormals = 0
|
|
totalUvs = 0
|
|
|
|
useColors = false
|
|
|
|
if sceneHasVColors and exportColor.checked then
|
|
(
|
|
|
|
totalColors = mergedColors.count
|
|
useColors = true
|
|
|
|
)
|
|
|
|
if exportNormal.checked then
|
|
(
|
|
|
|
totalNormals = mergedNormals.count
|
|
|
|
)
|
|
|
|
if exportUv.checked then
|
|
(
|
|
|
|
totalUvs = mergedUvs.count
|
|
|
|
)
|
|
|
|
-- Dump model
|
|
|
|
Format "{\n\n" to:ostream
|
|
|
|
-- Dump header
|
|
|
|
Format headerFormat maxFileName totalVertices totalNormals totalColors totalUvs totalFaces totalMaterials to:ostream
|
|
|
|
-- Dump all materials in the scene
|
|
|
|
ExportMaterials mergedMaterials mergedMaterialsColors
|
|
|
|
-- Dump merged data from all selected geometries
|
|
|
|
DumpVertices mergedVertices
|
|
|
|
if hasMorph then
|
|
(
|
|
DumpMorphTargets mergedMorphTargets
|
|
)
|
|
|
|
DumpNormals mergedNormals
|
|
DumpColors mergedColors useColors
|
|
DumpUvs mergedUvs
|
|
DumpFaces mergedFaces useColors
|
|
|
|
if hasSkin then
|
|
(
|
|
DumpBones bones boneOrder newIndices
|
|
DumpIndices influences bone_names newIndices
|
|
DumpWeights weights
|
|
DumpKeyframes keyframes boneOrder newIndices fps.value
|
|
)
|
|
|
|
-- Dump footer
|
|
|
|
Format footerFormat to:ostream
|
|
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Open and prepare a file handle for writing
|
|
|
|
function GetSaveFileStream =
|
|
(
|
|
zname = getFilenameFile maxFileName
|
|
zname += ".js"
|
|
|
|
fname = GetSaveFileName filename:zname types:"JavaScript file (*.js)|*.js|All Files(*.*)|*.*|"
|
|
if fname == undefined then
|
|
(
|
|
|
|
return undefined
|
|
|
|
)
|
|
|
|
ostream = CreateFile fname
|
|
if ostream == undefined then
|
|
(
|
|
|
|
MessageBox "Couldn't open file for writing !"
|
|
return undefined
|
|
|
|
)
|
|
|
|
return ostream
|
|
)
|
|
|
|
-------------------------------------------------------------------------------------
|
|
-- Export button click handler
|
|
|
|
on btn_export pressed do
|
|
(
|
|
ostream = GetSaveFileStream()
|
|
if ostream != undefined then
|
|
(
|
|
|
|
ExportScene()
|
|
close ostream
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
createDialog ThreeJSExporter width:300 |