4139 lines
111 KiB
Plaintext
Executable File
4139 lines
111 KiB
Plaintext
Executable File
-- Rockstar Material Utilities
|
|
-- Rockstar North
|
|
-- 14/3/2005
|
|
-- by Greg Smith
|
|
-- by Luke Openshaw
|
|
|
|
-- if you get add any functions to get texture maps
|
|
-- make sure they come out lower case. lots of comparisons
|
|
-- assume this. RsMakeSafeTextureName will return a lowercase
|
|
-- name
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- Uses
|
|
-----------------------------------------------------------------------------
|
|
--filein "pipeline/util/file.ms" -- loaded on startup by startup.ms
|
|
--filein "pipeline/util/string.ms" -- loaded on startup by startup.ms
|
|
--filein "rockstar/util/mapobj.ms" -- loaded on startup by startup.ms
|
|
--filein "rockstar/export/settings.ms" -- loaded on startup by startup.ms
|
|
filein "pipeline/util/drawablelod.ms"
|
|
filein "rockstar/util/lod.ms"
|
|
|
|
filein "pipeline/util/ExcludedTextures.ms"
|
|
filein "rockstar/util/material_funcs.ms"
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- Globals
|
|
-----------------------------------------------------------------------------
|
|
|
|
-- Set by RsGetShaderList:
|
|
global RSshaderList = undefined
|
|
|
|
global RsDiffuseTexMaxSize = 1024
|
|
global RsOtherTexMaxSize = 1024
|
|
|
|
global idxTexOptimised = (getAttrIndex "Gta Texture" "optimised")
|
|
global gRsCallCountRsGetTexMapsFromObjNoStrip = 0
|
|
-----------------------------------------------------------------------------
|
|
-- Functions
|
|
-----------------------------------------------------------------------------
|
|
|
|
--------------------------------------------------------------
|
|
-- Returns a list of objs without packed textured objects
|
|
--------------------------------------------------------------
|
|
fn RsGetInputObjectList inputObjList outputObjList =
|
|
(
|
|
local idxPackTextures = getattrindex "Gta Object" "Pack Textures"
|
|
|
|
local collectObjs = for obj in inputObjList where (getAttrClass obj != "Gta Object") or (getAttr obj idxPackTextures == False) collect obj
|
|
|
|
join outputObjList collectObjs
|
|
|
|
return outputObjList
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Diffuse map-slot name?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsDiffuseMap slotName =
|
|
(
|
|
local retval = case of
|
|
(
|
|
(not isKindOf slotName String):False
|
|
((matchPattern slotName pattern:"Diffuse*") and (not matchPattern slotName pattern:"*Palette*")):True
|
|
(matchPattern slotName pattern:"Color Texture*"):True
|
|
Default:False
|
|
)
|
|
|
|
return retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Palette map-slot name?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsPaletteMap slotName =
|
|
(
|
|
local retval = false
|
|
|
|
if (isKindOf slotName String) do
|
|
(
|
|
retval = (matchPattern slotName pattern:"*Palette*")
|
|
)
|
|
|
|
retval
|
|
)
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Specular map-slot name?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsSpecMap slotName =
|
|
(
|
|
local retval = false
|
|
|
|
if (isKindOf slotName String) do
|
|
(
|
|
retval = (matchPattern slotName pattern:"*Specular*")
|
|
)
|
|
|
|
retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Bump map-slot name?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsBumpMap slotName =
|
|
(
|
|
local retval = false
|
|
|
|
if (isKindOf slotName String) do
|
|
(
|
|
retval = (matchPattern slotName pattern:"*Bump*") or (matchPattern slotName pattern:"Normal Map*")
|
|
)
|
|
|
|
retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a cable-shader?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsCableTexture objMat =
|
|
(
|
|
local retval = false
|
|
|
|
if (isKindOf objMat Rage_Shader) do
|
|
(
|
|
retval = (matchPattern (RstGetShaderName objMat) pattern:"*cable*")
|
|
)
|
|
|
|
return retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Distance Map map-slot?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsDistanceMap slotName =
|
|
(
|
|
slotName == "Distance Map"
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Tint Palette map-slot?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsTintPalette slotName =
|
|
(
|
|
slotName == "Tint Palette"
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this a Terrain Blend map-slot?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsTerrainBlendMap slotName =
|
|
(
|
|
local retval = false
|
|
|
|
if (isKindOf slotName String) do
|
|
(
|
|
retval = (matchPattern slotName pattern:"*Blend Texture *")
|
|
)
|
|
|
|
return retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Is this texturemap export-exempt?
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsExportExempt mapname =
|
|
(
|
|
(mapname != undefined) and
|
|
(
|
|
RsExcludedTextures.CheckName(mapname)
|
|
)
|
|
)
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- Global flags used to control texturemap-collection functions:
|
|
-----------------------------------------------------------------------------
|
|
struct RsIncTexmaps
|
|
(
|
|
incDefault = true,
|
|
incDiffuse = true,
|
|
incSpec = true,
|
|
incNormal = true,
|
|
incExempt = false,
|
|
incPalette = true,
|
|
|
|
-- Set global flags:
|
|
fn setFlags inDefault diff: spec: normal: palette: =
|
|
(
|
|
incDefault = inDefault
|
|
if (diff != unsupplied) do (incDiffuse = diff)
|
|
if (spec != unsupplied) do (incSpec = spec)
|
|
if (normal != unsupplied) do (incNormal = normal)
|
|
if (palette != unsupplied) do (incPalette = palette)
|
|
|
|
return OK
|
|
),
|
|
|
|
-- Does a given texturemap match the current include-flags?
|
|
fn isIncluded texmapName texmapType =
|
|
(
|
|
local incMap = incDefault
|
|
|
|
if RsIsDiffuseMap texmaptype do (incMap = incDiffuse)
|
|
if RsIsPaletteMap texmaptype do (incMap = incPalette)
|
|
if RsIsTerrainBlendMap texmaptype do (incMap = incDiffuse)
|
|
if RsIsSpecMap texmaptype do (incMap = incSpec)
|
|
if RsIsBumpMap texmaptype do (incMap = incNormal)
|
|
if RsIsExportExempt texmapname do (incMap = incExempt)
|
|
|
|
return incMap
|
|
)
|
|
)
|
|
gRsIncTexmaps = RsIncTexmaps()
|
|
RsSetMapsFlags = gRsIncTexmaps.setFlags
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Gets texturemap data from an object's lights:
|
|
----------------------------------------------------------------------------------------
|
|
fn RsCheckForLighttextures obj texmaplist maxsizelist:#() isbumplist:#() exemptionList:#() texmapobjlist:#() maptypelist:#() texturetemplatelist:#() matIdList:#() =
|
|
(
|
|
if (not isValidNode obj) do return False
|
|
|
|
for childobj in obj.children do
|
|
(
|
|
local lightShadowMap = undefined
|
|
|
|
case of
|
|
(
|
|
(isproperty childobj "shadowprojectormap"):
|
|
(
|
|
lightShadowMap = childobj.shadowprojectormap
|
|
)
|
|
(isKindof childobj RageLight):
|
|
(
|
|
local underlyingLight = childobj
|
|
while isProperty underlyingLight "delegate" do
|
|
underlyingLight = underlyingLight.delegate
|
|
|
|
if isproperty underlyingLight "shadowprojectormap" then
|
|
(
|
|
underlyingLight.shadowprojectormap = childobj.lightShadowMap
|
|
lightShadowMap = childobj.delegate.shadowprojectormap
|
|
)
|
|
)
|
|
)
|
|
|
|
if (lightShadowMap != undefined) and (lightShadowMap.filename != "") do
|
|
(
|
|
if (appendIfUnique texmaplist (toLower lightShadowMap.filename)) do
|
|
(
|
|
append maptypelist "LightMap"
|
|
append texmapobjlist lightShadowMap
|
|
append maxsizelist 1024
|
|
append isbumplist false
|
|
append exemptionList false
|
|
append texturetemplatelist "Diffuse"
|
|
append matIdList -1 -- Default no-matid value
|
|
|
|
if (not doesFileExist lightShadowMap.filename) do
|
|
(
|
|
gRsUlog.LogWarning ("Texture "+ lightShadowMap.filename +" on light "+childobj.name+" couldn't be found!") context:childobj
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
return texmaplist
|
|
)
|
|
|
|
fn RsHasLightTxd obj =
|
|
(
|
|
local txList = #()
|
|
RsCheckForLighttextures obj txList
|
|
|
|
local HasLightTx = (txList.count > 0)
|
|
|
|
for child in obj.children while (not HasLightTx) do
|
|
(
|
|
HasLightTx = RsHasLightTxd child
|
|
)
|
|
|
|
return HasLightTx
|
|
)
|
|
|
|
-----------------------------------------------------------------
|
|
-- Build a list of a material's submaterials of a particular class
|
|
-----------------------------------------------------------------
|
|
fn RSgetMatClassSubMats mat getClass matList:#() =
|
|
(
|
|
case (classOf mat) of
|
|
(
|
|
MultiMaterial:
|
|
(
|
|
for subMat in mat.materiallist do
|
|
(
|
|
RSgetMatClassSubMats subMat getClass matList:matList
|
|
)
|
|
)
|
|
getClass:
|
|
(
|
|
appendIfUnique matList mat
|
|
)
|
|
)
|
|
|
|
matList
|
|
)
|
|
|
|
fn RsIsResizeExempt map maptypename objMat =
|
|
(
|
|
local retval = (not getAttr map idxTexOptimised) or (RsIsTintPalette maptypename) or (RsIsDistanceMap maptypename) or (RsIsCableTexture objMat)
|
|
|
|
return retval
|
|
)
|
|
|
|
fn RsGetDistanceAlphaMapResultMap distAlphaMap =
|
|
(
|
|
-- Make my name safe:
|
|
distAlphaMap.name = substituteString distAlphaMap.name " " "_"
|
|
distAlphaMap.name = substituteString distAlphaMap.name "#" ""
|
|
|
|
-- Make sure result is not downscaled:
|
|
setAttr distAlphaMap idxTexOptimised False
|
|
|
|
local resultmap = undefined
|
|
if (distAlphaMap.resultmap != undefined) do
|
|
(
|
|
resultmap = distAlphaMap.resultmap
|
|
)
|
|
|
|
-- Check whether it's a valid file path; if not, export it:
|
|
if (resultmap == undefined) or (resultmap.filename == "") or ((getFileSize resultmap.filename) == 0) do -- Rebuild if necessary
|
|
(
|
|
local diffuseMapPath = "C:\\"
|
|
if (distAlphaMap.diffusemap != undefined) do
|
|
(
|
|
diffuseMapPath = getFilenamePath distAlphaMap.diffuseMap
|
|
)
|
|
|
|
|
|
if (distAlphaMap.Create False diffuseMapPath) do
|
|
(
|
|
resultmap = distAlphaMap.resultmap
|
|
)
|
|
|
|
format "Building new Distance map to %\n" resultmap.filename
|
|
|
|
--doublecheck whether it worked
|
|
if (resultmap == "") then
|
|
(
|
|
local msg=stringstream ""
|
|
format "Result for distanceAlphaMap % could not be created!" distAlphaMap.name to:msg
|
|
messagebox msg
|
|
)
|
|
)
|
|
|
|
return resultmap
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Makes list of texturemaps used on object, the number of
|
|
-- polys they use, and the faces they use
|
|
----------------------------------------------------------------------------------------
|
|
fn RsMatGetMapIdsUsedOnObjectWithCount obj mapList mat: polycount: faceidlists: maxMatId: =
|
|
(
|
|
if (mat == unsupplied) do
|
|
(
|
|
mat = obj.material
|
|
)
|
|
|
|
if (isKindOf obj col_mesh) do (obj = getColMesh obj)
|
|
|
|
local isMesh = (isKindOf obj Editable_Mesh) or (isKindOf obj TriMesh)
|
|
local doPolyCount = (polycount != unsupplied)
|
|
local doFaceIDlists = (faceidlists != unsupplied)
|
|
|
|
local limitMatIds = (maxMatId != unsupplied)
|
|
|
|
if
|
|
(
|
|
(
|
|
isMesh or
|
|
isKindOf obj Editable_Poly or
|
|
isKindOf obj PolyMeshObject
|
|
) and
|
|
(mat != undefined) and (hasProperty mat "materialList")
|
|
)
|
|
then
|
|
(
|
|
local objGetFaceMatId = if isMesh then getfacematid else polyop.getfacematid
|
|
|
|
for i = 1 to (getnumfaces obj) do
|
|
(
|
|
local matID = objGetFaceMatId obj i
|
|
|
|
if matID != undefined do
|
|
(
|
|
if limitMatIds do
|
|
(
|
|
if (matID > maxMatId) do
|
|
(
|
|
matID = (mod matID maxMatId) as integer
|
|
if (matID == 0) do (matID = maxMatId)
|
|
)
|
|
)
|
|
|
|
local idxFound = finditem mapList matID
|
|
|
|
if idxFound == 0 then
|
|
(
|
|
append mapList matID
|
|
if doPolyCount do (append polycount 1)
|
|
if doFaceIDlists do (append faceidlists #(i))
|
|
)
|
|
else
|
|
(
|
|
if doPolyCount do (polycount[idxFound] += 1)
|
|
if doFaceIDlists do (append faceidlists[idxFound] i)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
append mapList -1
|
|
if doPolyCount do (append polycount 0)
|
|
)
|
|
|
|
return mapList
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Makes list of texturemaps used on object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsMatGetMapIdsUsedOnObject obj mapList mat: maxMatId: =
|
|
(
|
|
RsMatGetMapIdsUsedOnObjectWithCount obj mapList mat:mat maxMatId:maxMatId
|
|
sort mapList
|
|
|
|
return mapList
|
|
)
|
|
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- returns the nth texmap name in the rage shader
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapNameFromRsShader mat texmapidx =
|
|
(
|
|
local retval = undefined
|
|
|
|
local texmapidx = (texmapidx - 1)
|
|
local numVars = RstGetVariableCount mat
|
|
local texmapCount = -1
|
|
|
|
if (numVars != undefined) and (numVars >= 1) do
|
|
(
|
|
for i = 1 to numVars where (RstGetVariableType mat i == "texmap") while (retval == undefined) do
|
|
(
|
|
texmapCount += 1
|
|
|
|
if (texmapCount == texmapidx) do
|
|
(
|
|
retval = (RstGetVariableName mat i)
|
|
)
|
|
)
|
|
)
|
|
retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Returns var-index for a given texmap-slot id:
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapIdForRstMtl mat texmapidx =
|
|
(
|
|
texmapidx = texmapidx - 1
|
|
numVars = RstGetVariableCount mat
|
|
texmapCount = -1
|
|
|
|
retval = undefined
|
|
|
|
if numVars != undefined and numVars >= 1 do
|
|
(
|
|
for i = 1 to numVars
|
|
where (RstGetVariableType mat i == "texmap") and (retval == undefined)
|
|
do
|
|
(
|
|
texmapCount += 1
|
|
if texmapCount == texmapidx do (retval = i)
|
|
)
|
|
)
|
|
retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- removes spaces from texture file names
|
|
----------------------------------------------------------------------------------------
|
|
fn RsMakeSafeTextureName namein =
|
|
(
|
|
toLower (RsMakeSafeSlashes namein)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Removes paths from texpath-string
|
|
-- (which can include multiple paths in one string)
|
|
-- Returned string will -not- include '+' and '>' tokens
|
|
----------------------------------------------------------------------------------------
|
|
fn RsStripTexturePath texpath =
|
|
(
|
|
local retval = ""
|
|
|
|
if (texpath != undefined) and (texpath != "") do
|
|
(
|
|
local PathTokens = filterstring texpath "+>"
|
|
|
|
for SubPath in PathTokens do
|
|
(
|
|
local TexName = GetFilenameFile SubPath
|
|
|
|
if (TexName != undefined) do
|
|
(
|
|
retval += TexName
|
|
)
|
|
)
|
|
)
|
|
|
|
return retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Returns a material's variable-index for a given texmap slot 'texmapIdx'
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapVariableIndex mat texmapIdx: byVarName: =
|
|
(
|
|
local result = 0
|
|
|
|
if (texmapidx == unsupplied) and (byVarName == unsupplied) do return result
|
|
|
|
local texmapCount = 0
|
|
local varCount = RstGetVariableCount mat
|
|
|
|
local doByVarName = (byVarName != unsupplied)
|
|
|
|
for i = 1 to varCount while (result == 0) do
|
|
(
|
|
if (RstGetVariableType mat i == "texmap") do
|
|
(
|
|
texmapCount += 1
|
|
|
|
if doByVarName then
|
|
(
|
|
if ((RstGetVariableName mat i) == byVarName) do
|
|
(
|
|
result = i
|
|
)
|
|
)
|
|
else
|
|
(
|
|
if (texmapCount == texmapIdx) do
|
|
(
|
|
result = i
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
return result
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetProceduralFaces obj mat facesout = (
|
|
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined then (
|
|
|
|
if classof mat == MultiMaterial then (
|
|
|
|
for i = 1 to mat.materialIDList.count do (
|
|
|
|
if classof mat.materiallist[i] == RexBoundMtl then (
|
|
|
|
if RexGetProceduralName mat.materiallist[i] != "" then (
|
|
|
|
numFaces = getnumfaces obj
|
|
|
|
for j = 1 to numFaces do (
|
|
|
|
if classof obj == Editable_Mesh then (
|
|
|
|
matID = getfacematid obj j
|
|
) else if classof obj == Editable_Poly or classof obj == PolyMeshObject then (
|
|
|
|
matID = polyop.getfacematid obj j
|
|
)
|
|
|
|
if matID == mat.materialIDList[i] then (
|
|
|
|
append facesout j
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
) else if classof mat == RexBoundMtl then (
|
|
|
|
if RexGetProceduralName mat != "" then (
|
|
|
|
numFaces = getnumfaces obj
|
|
|
|
for j = 1 to numFaces do (
|
|
|
|
append facesout j
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
return false
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetDoesObjUseProcedurals obj mat = (
|
|
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined then (
|
|
|
|
if classof mat == MultiMaterial then (
|
|
|
|
matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
|
|
for i = 1 to matlist.count do (
|
|
|
|
matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if matidx != 0 then (
|
|
|
|
if RsGetDoesObjUseProcedurals obj mat.materiallist[matidx] == true then (
|
|
|
|
return true
|
|
)
|
|
)
|
|
)
|
|
) else if classof mat == RexBoundMtl then (
|
|
|
|
if RexGetProceduralName mat != "" then (
|
|
|
|
return true
|
|
)
|
|
)
|
|
)
|
|
|
|
return false
|
|
)
|
|
|
|
fn RsSpecularMapHack obj mat = (
|
|
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined do
|
|
(
|
|
case classof mat of
|
|
(
|
|
MultiMaterial:
|
|
(
|
|
matlist = #()
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
for i = 1 to matlist.count do (
|
|
if id == matlist[i] then (
|
|
matidx = finditem mat.materialIDList matlist[i]
|
|
if matidx != 0 then (
|
|
RsSpecularMapHack obj mat.materiallist[matidx]
|
|
)
|
|
)
|
|
)
|
|
)
|
|
Rage_Shader:
|
|
(
|
|
numVars = RstGetVariableCount mat
|
|
for i = 1 to numVars do
|
|
(
|
|
nameVar = RstGetVariableName mat i
|
|
if nameVar == "Specular Falloff" then
|
|
(
|
|
specVar = RstGetVariable mat i
|
|
if specVar > 199.0 and specVar < 201.0 then (
|
|
RstSetVariable mat i 201.5
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
-- Returns True if shaderName is on the shader-list:
|
|
fn RsShaderExists shaderName =
|
|
(
|
|
(findItem (::RsGetShaderList()) shaderName) != 0
|
|
)
|
|
|
|
-- Set all shaders in a material to use appropriate Default versions:
|
|
fn RsSetMaterialToAllDefault mat isPed:false quiet:true =
|
|
(
|
|
case classof mat of
|
|
(
|
|
MultiMaterial:
|
|
(
|
|
for childmat in mat.materiallist do (RsSetMaterialToAllDefault childmat isPed:isPed)
|
|
)
|
|
Rage_Shader:
|
|
(
|
|
local oldName = toLower (getFilenameFile (RstGetShaderName mat))
|
|
|
|
local defPattern = if isPed then "ped_default*" else "default*"
|
|
|
|
if not matchPattern oldName pattern:defPattern do
|
|
(
|
|
local newName = oldName
|
|
|
|
if isPed and matchPattern oldName pattern:"ped_*" do
|
|
(
|
|
newName = substring oldname 5 -1
|
|
)
|
|
|
|
-- This shader's Default version will just have the first name-token:
|
|
local nameTokens = filterString newName "_"
|
|
local newName = nameTokens[1]
|
|
|
|
-- Special-case shader-mappings:
|
|
case of
|
|
(
|
|
(findItem #("decal", "alpha") newName != 0):
|
|
(
|
|
newName = "cutout"
|
|
)
|
|
)
|
|
|
|
newName = "default_" + newname
|
|
|
|
if isPed do
|
|
(
|
|
newName = "ped_" + newName
|
|
)
|
|
|
|
-- If this new defaulty-name isn't on the shader-list, then use the default defaulty-name:
|
|
if not RsShaderExists newName do
|
|
(
|
|
newName = if isPed then "ped_default" else "default"
|
|
)
|
|
|
|
if (oldName != newName) do
|
|
(
|
|
local logMsg = stringStream ""
|
|
format "Changing shader to Default version: % to %\n" oldName newName to:logMsg
|
|
gRsUlog.LogMessage (logMsg as string) context:"RsSetMaterialToAllDefault" quiet:quiet
|
|
RstSetShaderName mat newName
|
|
)
|
|
)
|
|
)
|
|
Array:
|
|
(
|
|
for childmat in mat do(
|
|
RsSetMaterialToAllDefault childmat isPed:isPed quiet:quiet
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
fn RsSetMaterialTexturesToLod mat SLOD:false =
|
|
(
|
|
-- CHANGE TEXTUREMAPS TO LOD VERSIONS: (if found)
|
|
-- Set texturemaps to use LOD/SLOD versions if available:
|
|
local mainTexLodDir = RsProjectGetArtDir() + "/textures/lod/"
|
|
|
|
local findSuffixes = if SLOD then #("_slod.*", "_slod1.*") else #("_lod.*")
|
|
local matchSuffixes = for suffix in findSuffixes collect ("*" + suffix)
|
|
|
|
local numTexMap = getNumSubTexmaps mat
|
|
for n = 1 to numTexMap do
|
|
(
|
|
local subTexMap = getSubTexmap mat n
|
|
local newTexfile
|
|
|
|
if (subTexMap != undefined) and (subTexMap.filename != "") do
|
|
(
|
|
local texFilename = subTexMap.filename
|
|
|
|
-- Skip files that already have a matching suffix:
|
|
local doFile = true
|
|
for suffixPattern in matchSuffixes while doFile do
|
|
(
|
|
if matchPattern texFilename pattern:suffixPattern do
|
|
(
|
|
doFile = false
|
|
)
|
|
)
|
|
|
|
if doFile do
|
|
(
|
|
local filenameName = toLower (getFilenameFile texFilename)
|
|
|
|
local lodSuffixStart = case of
|
|
(
|
|
(not SLOD and (matchPattern filenameName pattern:"*slod")):(findString filenameName "slod")
|
|
(SLOD and (matchPattern filenameName pattern:"*lod")):(findString filenameName "lod")
|
|
default:0
|
|
)
|
|
|
|
local baseFilename = filenameName
|
|
|
|
-- Strip _/s/lod suffix:
|
|
if (lodSuffixStart != 0) do
|
|
(
|
|
lodSuffixStart -= 1
|
|
|
|
if filenameName[lodSuffixStart] == "_" do
|
|
(
|
|
lodSuffixStart -= 1
|
|
)
|
|
|
|
baseFilename = subString filenameName 1 lodSuffixStart
|
|
)
|
|
|
|
-- Look for matching _lod texture in same folder, lod subfolder, or main lod-texture folder:
|
|
local fileDir = getFilenamePath texFilename
|
|
|
|
-- Move up from Lod subdirectory, if that's what this is:
|
|
if matchPattern (pathConfig.stripPathToLeaf fileDir) pattern:"lod*" do
|
|
(
|
|
fileDir = (pathConfig.removePathLeaf fileDir) + "/"
|
|
)
|
|
|
|
for findSuffix in findSuffixes while (newTexfile == undefined) do
|
|
(
|
|
local findName = baseFilename + findSuffix
|
|
|
|
local lodFile = #()
|
|
|
|
for checkDir in #(fileDir, fileDir + "lods/", fileDir + "lod/", mainTexLodDir) while (lodFile.count == 0) do
|
|
(
|
|
lodFile = getFiles (checkDir + findName)
|
|
)
|
|
|
|
if (lodFile.count != 0) then
|
|
(
|
|
newTexfile = lodFile[1]
|
|
)
|
|
)
|
|
)
|
|
|
|
if (newTexfile != undefined) then
|
|
(
|
|
--format "Changing texture to %LOD version: % to %\n" (if SLOD then "S" else "") texFilename newTexfile
|
|
subTexMap.filename = newTexfile
|
|
)
|
|
else --flag it up as a missing lod texture
|
|
(
|
|
--format "Missing LOD texture\n"
|
|
--messageBox ("There is a missing LOD texture for:\n" + (getFilenameFile texFilename)) title:"Missing LOD Texture"
|
|
gRsULog.LogWarning "Missing lod texture paths\n" files:texFilename
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Gets list of texmaps used by a material
|
|
-- 'typeList' and 'matIdList' can be used to return matching lists of texmap-types and matIds
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapListForMat mat texmaplist texmaptypelist:#() matIdList:#() matId:1 =
|
|
(
|
|
case of
|
|
(
|
|
(mat == undefined):()
|
|
(isKindOf mat MultiMaterial):
|
|
(
|
|
for i = 1 to mat.materiallist.count do
|
|
(
|
|
RsGetTexMapListForMat mat.materiallist[i] texmaplist texmaptypelist:texmaptypelist matIdList:matIdList matId:i
|
|
)
|
|
)
|
|
Default:
|
|
(
|
|
isAlphaShader = false
|
|
numTexMaps = getNumSubTexmaps mat
|
|
|
|
if (RstGetIsAlphaShader mat) do
|
|
(
|
|
isAlphaShader = true
|
|
numTexMaps = numTexMaps / 2
|
|
numTexMaps = numTexMaps + 1
|
|
)
|
|
|
|
numValidTexMaps = 0
|
|
|
|
for i = 1 to numTexMaps do
|
|
(
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if classOf subTexMap == CompositeTexturemap then
|
|
(
|
|
for t=1 to getNumSubTexmaps subTexMap by 2 do
|
|
(
|
|
local thisSubMap = getSubTexmap subTexMap t
|
|
if thisSubMap.filename != "" then numValidTexMaps = numValidTexMaps + 1
|
|
)
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) and (subTexMap.filename != "") do
|
|
(
|
|
numValidTexMaps += 1
|
|
)
|
|
|
|
)
|
|
|
|
for i = 1 to numTexMaps do
|
|
(
|
|
local subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap CompositeTexturemap) do
|
|
(
|
|
for t=1 to getNumSubTexmaps subTexMap by 2 do
|
|
(
|
|
local thisSubMap = getSubTexmap subTexMap t
|
|
if (thisSubMap.filename != "") do
|
|
(
|
|
if (isKindOf mat Rage_Shader) then
|
|
(
|
|
texmapType = RsGetTexMapNameFromRsShader mat i
|
|
append texmaptypelist texmapType
|
|
)
|
|
else
|
|
(
|
|
append texmaptypelist undefined
|
|
)
|
|
append texmaplist thisSubMap
|
|
append matIdList matId
|
|
)
|
|
)
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if (subTexMap.filename != "") do
|
|
(
|
|
if (isKindOf mat Rage_Shader) then
|
|
(
|
|
texmapType = RsGetTexMapNameFromRsShader mat i
|
|
append texmaptypelist texmapType
|
|
)
|
|
else
|
|
(
|
|
append texmaptypelist undefined
|
|
)
|
|
append texmaplist subTexMap
|
|
append matIdList matId
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the main texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapList obj mat texmaplist shaderlist matidlist slotlist withIsScaleUv:true shaderid:1 matid:1 = (
|
|
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined then (
|
|
|
|
if classof mat == MultiMaterial then (
|
|
|
|
matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObjectWithCount obj matlist
|
|
|
|
for i = 1 to matlist.count do
|
|
(
|
|
matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if matidx != 0 do
|
|
(
|
|
RsGetTexMapList obj mat.materiallist[matidx] texmaplist shaderlist matidlist slotlist shaderid:i matid:matidx
|
|
)
|
|
)
|
|
)
|
|
else if classof mat == XRef_Material then (
|
|
|
|
RsGetTexMapList obj (mat.getsrcitem()) texmaplist
|
|
)
|
|
else (
|
|
|
|
isAlphaShader = false
|
|
numTexMaps = getNumSubTexmaps mat
|
|
|
|
if RstGetIsAlphaShader mat then (
|
|
|
|
isAlphaShader = true
|
|
numTexMaps = numTexMaps / 2
|
|
numTexMaps = numTexMaps + 1
|
|
)
|
|
|
|
local slotIdx = 1
|
|
|
|
for i = 1 to numTexMaps do
|
|
(
|
|
local subTexMap = getSubTexmap mat i
|
|
local isAlpha = false
|
|
|
|
if (isKindOf mat Standardmaterial) and (i == 7) then
|
|
(
|
|
isAlpha = true
|
|
)
|
|
else
|
|
(
|
|
if isAlphaShader and (i == numTexMaps) do
|
|
(
|
|
isAlpha = true
|
|
)
|
|
)
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
--print "validation check 2"
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if (subTexMap.filename != "") do
|
|
(
|
|
append texmaplist subTexMap
|
|
append shaderlist shaderid
|
|
append matidlist matid
|
|
|
|
if isAlpha then
|
|
(
|
|
append slotlist (-1)
|
|
)
|
|
else
|
|
(
|
|
append slotlist slotIdx
|
|
)
|
|
)
|
|
|
|
if (not isAlpha) do
|
|
(
|
|
slotIdx += 1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the main texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetMainTexMapsFromMaterial obj mat texmaplist firstpass:true = (
|
|
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined then (
|
|
|
|
if classof mat == MultiMaterial then (
|
|
|
|
matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
|
|
for i = 1 to matlist.count do (
|
|
|
|
matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if matidx != 0 then (
|
|
|
|
RsGetMainTexMapsFromMaterial obj mat.materiallist[matidx] texmaplist firstpass:false
|
|
)
|
|
)
|
|
)
|
|
else if classof mat == XRef_Material then (
|
|
|
|
RsGetMainTexMapsFromMaterial obj (mat.getsrcitem()) texmaplist
|
|
)
|
|
else if classof mat == Standardmaterial then (
|
|
|
|
diffuseName = ""
|
|
subTexMap = getSubTexmap mat 2
|
|
|
|
append texmaplist subTexMap
|
|
) else if classof mat == Rage_Shader then (
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
if numTexMap > 0 then (
|
|
|
|
subTexMap = getSubTexmap mat 1
|
|
|
|
append texmaplist subTexMap
|
|
)
|
|
)
|
|
else if classof mat == DirectX_9_Shader then (
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
if numTexMap > 0 then (
|
|
|
|
subTexMap = getSubTexmap mat 1
|
|
|
|
append texmaplist subTexMap
|
|
)
|
|
)
|
|
|
|
if firstpass then (
|
|
|
|
for childobj in obj.children do (
|
|
|
|
RsGetMainTexMapsFromMaterial childobj childobj.material texmaplist
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the main texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetMainTexMapsFromMaterialByID obj mat id texmaplist = (
|
|
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined then (
|
|
|
|
if classof mat == MultiMaterial then (
|
|
|
|
matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
|
|
for i = 1 to matlist.count do (
|
|
|
|
if id == matlist[i] then (
|
|
|
|
matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if matidx != 0 then (
|
|
|
|
RsGetMainTexMapsFromMaterial obj mat.materiallist[matidx] texmaplist
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else if classof mat == XRef_Material then (
|
|
|
|
RsGetMainTexMapsFromMaterial obj (mat.getsrcitem()) texmaplist
|
|
)
|
|
else if classof mat == Standardmaterial then (
|
|
|
|
diffuseName = ""
|
|
subTexMap = getSubTexmap mat 2
|
|
|
|
append texmaplist subTexMap
|
|
) else if classof mat == Rage_Shader then (
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
if numTexMap > 1 then (
|
|
|
|
subTexMap = getSubTexmap mat 1
|
|
|
|
append texmaplist subTexMap
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
fn RsGetEmptyTexMaps obj mat slotlist objnamelist texmapnamelist currentslot:-1 =
|
|
(
|
|
if obj != undefined and (not isRefObj obj) and (not isInternalRef obj) and mat != undefined then
|
|
(
|
|
if classof mat == MultiMaterial then
|
|
(
|
|
local matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
|
|
for i = 1 to matlist.count do
|
|
(
|
|
local matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if (matidx != 0) do
|
|
(
|
|
RsGetEmptyTexMaps obj mat.materiallist[matidx] slotlist objnamelist texmapnamelist currentslot:matlist[i]
|
|
)
|
|
)
|
|
)
|
|
else if classof mat == Rage_Shader then
|
|
(
|
|
varCount = RstGetVariableCount mat
|
|
texmapCount = 0
|
|
|
|
if (varCount != undefined) and (varCount >= 1) do
|
|
(
|
|
for i = 1 to varCount do
|
|
(
|
|
if retval == undefined and RstGetVariableType mat i == "texmap" then
|
|
(
|
|
texmapCount = texmapCount + 1
|
|
|
|
if ( getNumSubTexmaps mat < texmapCount ) then
|
|
continue
|
|
|
|
varName = RstGetVariableName mat i
|
|
varSubMap = getSubTexmap mat texmapCount
|
|
|
|
if (isKindOf varSubMap DistanceAlphaMap) do
|
|
(
|
|
varSubMap = varSubMap.resultmap
|
|
)
|
|
|
|
if (not isKindOf varSubMap CompositeTexturemap) do
|
|
(
|
|
local varFilename = ""
|
|
|
|
if (isKindOf varSubMap Bitmaptexture) and (varSubMap.filename != undefined) and (varSubMap.filename != "") do
|
|
(
|
|
varFilename = RsMakeSafeTextureName(RsStripTexturePath(varSubMap.filename))
|
|
)
|
|
|
|
if varFilename == "" and varName != "Diffuse Texture" do
|
|
(
|
|
append objnamelist obj.name
|
|
append slotlist currentslot
|
|
append texmapnamelist varName
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Returns bitArray of matIds used on an object's mesh,
|
|
-- with no special processing (also works on TriMeshes)
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetMatIdsUsedByObj obj =
|
|
(
|
|
local objGetFaceMatID = RsGetFaceMatIDFunc obj
|
|
|
|
local retVal = #{}
|
|
|
|
for faceNum = 1 to (getNumFaces obj) do
|
|
(
|
|
local faceMatId = objGetFaceMatID obj faceNum
|
|
|
|
if (faceMatId != undefined) do
|
|
(
|
|
retVal[faceMatId] = true
|
|
)
|
|
)
|
|
|
|
return retVal
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Returns a list of texture-paths used by a material.
|
|
-- 'matIds' can be used to limit the multimaterial ids used.
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexPathsFromMat mat matIds:#{} texList:#() =
|
|
(
|
|
case classOf mat of
|
|
(
|
|
MultiMaterial:
|
|
(
|
|
local allMatIds = (matIds.numberSet == 0)
|
|
local matIdList = #()
|
|
|
|
for matIdx = 1 to mat.materialIDList.count do
|
|
(
|
|
local matId = mat.materialIDList[matIdx]
|
|
|
|
if allMatIds or matIds[matId] do
|
|
(
|
|
RsGetTexPathsFromMat mat.materialList[matIdx] matIds:matIds texList:texList
|
|
)
|
|
)
|
|
)
|
|
XRef_Material:
|
|
(
|
|
RsGetTexPathsFromMat mat.getsrcitem() matIds:matIds texList:texList
|
|
)
|
|
CompositeTexturemap: -- That's a Texturemap, not material
|
|
(
|
|
local subTexMap = mat
|
|
local numMaps = getNumSubTexMaps subTexMap
|
|
|
|
for j = 1 to numMaps do
|
|
(
|
|
local subSubTexMap = getSubTexmap mat j
|
|
RsGetTexPathsFromMat subSubTexMap matIds:matIds texList:texList
|
|
)
|
|
)
|
|
UndefinedClass:()
|
|
default:
|
|
(
|
|
if (isKindOf mat textureMap) then
|
|
(
|
|
local subTexMap = mat
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) and (subTexMap.filename != "") then
|
|
(
|
|
local texmapname = (RsMakeSafeTextureName subTexMap.filename)
|
|
|
|
appendIfUnique texList texmapname
|
|
)
|
|
)
|
|
else
|
|
(
|
|
local numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do
|
|
(
|
|
local subTexMap = getSubTexmap mat i
|
|
|
|
RsGetTexPathsFromMat subTexMap matIds:matIds texList:texList
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
return texList
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromMaterialWithMap obj mat texmaplist bitmaplist maptypelist:#() matIdList:#() matId:1 incID:-1 =
|
|
(
|
|
RsCheckForLighttextures obj texmaplist texmapobjlist:bitmaplist maptypelist:maptypelist matIdList:matIdList
|
|
|
|
if (obj != undefined) and (not isRefObj obj) and (not isInternalRef obj) and (mat != undefined) do
|
|
(
|
|
if classof mat == MultiMaterial then
|
|
(
|
|
local objMatIds = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj objMatIds maxMatId:mat.numSubs
|
|
|
|
for i = 1 to objMatIds.count do
|
|
(
|
|
local matId = objMatIds[i]
|
|
|
|
if (incID == -1) or (incID == matId) then
|
|
(
|
|
local matidx = finditem mat.materialIDList matId
|
|
|
|
if (matidx != 0) do
|
|
(
|
|
RsGetTexMapsFromMaterialWithMap obj mat.materiallist[matidx] texmaplist bitmaplist maptypelist:maptypelist matIdList:matIdList matId:matId incID:incID
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else if classof mat == XRef_Material then
|
|
(
|
|
RsGetTexMapsFromMaterialWithMap obj (mat.getsrcitem()) texmaplist bitmaplist maptypelist:maptypelist matIdList:matIdList matId:matId incID:incID
|
|
)
|
|
else if classof mat == Standardmaterial then
|
|
(
|
|
diffuseName = ""
|
|
subTexMap = getSubTexmap mat 2
|
|
subTexMapMain = getSubTexmap mat 2
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
--print "validation check 4"
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if (subTexMap.filename != "") do
|
|
(
|
|
texmapname = toLower(subTexMap.filename)
|
|
|
|
diffuseName = texmapname
|
|
)
|
|
|
|
subTexMap = getSubTexmap mat 7
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) and (subTexMap.filename != "") do
|
|
(
|
|
texmapname = toLower(subTexMap.filename)
|
|
|
|
diffuseName = diffuseName + "+" + texmapname
|
|
)
|
|
)
|
|
|
|
if diffuseName != "" do
|
|
(
|
|
diffuseName = RsMakeSafeTextureName(RsStripTexturePath diffuseName)
|
|
|
|
if finditem texmaplist diffuseName == 0 do
|
|
(
|
|
append texmaplist diffuseName
|
|
append bitmaplist subTexMapMain
|
|
append maptypelist "Diffuse"
|
|
append matIdList matId
|
|
)
|
|
)
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do
|
|
(
|
|
if (i != 2) and (i != 7) do
|
|
(
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) and (subTexMap.filename != "") do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath (subTexMap.filename))
|
|
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
local maptype = case i of
|
|
(
|
|
4:"Specular"
|
|
9:"Bump"
|
|
Default:"Default"
|
|
)
|
|
|
|
append texmaplist texmapname
|
|
append bitmaplist subTexMap
|
|
append maptypelist maptype
|
|
append matIdList matId
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
) else if classof mat == Rage_Shader then (
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
if RstGetIsAlphaShader mat then (
|
|
|
|
numTexMap = numTexMap / 2
|
|
)
|
|
|
|
for i = 1 to numTexMap do (
|
|
|
|
texmapname = ""
|
|
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if classof subTexMap == DistanceAlphaMap then
|
|
(
|
|
--print "validation check 6"
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
if classof subTexMap == Bitmaptexture then (
|
|
|
|
if subTexMap.filename != "" then (
|
|
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath(subTexMap.filename))
|
|
)
|
|
|
|
if RstGetIsAlphaShader mat then (
|
|
|
|
local alphaTexMap = getSubTexmap mat (i + numTexMap)
|
|
|
|
if classof alphaTexMap == Bitmaptexture then (
|
|
|
|
if alphaTexMap.filename != "" then (
|
|
|
|
texmapname += "+" + RsMakeSafeTextureName(RsStripTexturePath (alphaTexMap.filename))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else if classof subTexMap == CompositeTexturemap then (
|
|
|
|
numMaps = getnumsubtexmaps subTexMap
|
|
|
|
for j = 1 to numMaps do (
|
|
|
|
subsubTexMap = getSubTexmap subTexMap j
|
|
|
|
if classof subsubTexMap == Bitmaptexture then (
|
|
|
|
if subsubTexMap.filename != "" then (
|
|
|
|
if j != 1 then (
|
|
|
|
texmapname += ">"
|
|
)
|
|
|
|
texmapname += RsMakeSafeTextureName(RsStripTexturePath(subsubTexMap.filename))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if texmapname != "" then
|
|
(
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
local texmaptype = RsGetTexMapNameFromRsShader mat i
|
|
local addMap = gRsIncTexmaps.isIncluded texmapName texmapType
|
|
|
|
if addMap do
|
|
(
|
|
append texmaplist texmapname
|
|
append bitmaplist subTexMap
|
|
append maptypelist texmaptype
|
|
append matIdList matId
|
|
)
|
|
)
|
|
)
|
|
)
|
|
) else if classof mat == DirectX_9_Shader then (
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
|
|
for i = 1 to numTexMap do (
|
|
|
|
texmapname = ""
|
|
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
if (isKindOf subTexMap Bitmaptexture) then
|
|
(
|
|
if (subTexMap.filename != "") do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath(subTexMap.filename))
|
|
)
|
|
|
|
if (RstGetIsAlphaShader mat) do
|
|
(
|
|
local alphaTexMap = getSubTexmap mat (i + numTexMap)
|
|
|
|
if (isKindOf alphaTexMap Bitmaptexture) and (alphaTexMap.filename != "") do
|
|
(
|
|
texmapname += "+" + RsMakeSafeTextureName(RsStripTexturePath (alphaTexMap.filename))
|
|
)
|
|
)
|
|
)
|
|
|
|
if (texmapname != "") do
|
|
(
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
append texmaplist texmapname
|
|
append bitmaplist subTexMap
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do
|
|
(
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
if (isKindOf subTexMap Bitmaptexture) and (subTexMap.filename != "") do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath (subTexMap.filename))
|
|
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
append texmaplist texmapname
|
|
append bitmaplist subTexMap
|
|
append maptypelist "Default"
|
|
append matIdList matId
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by a material
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromMaterial obj mat texmaplist maxsizelist isbumplist =
|
|
(
|
|
RsCheckForLighttextures obj texmaplist maxsizelist:maxsizelist isbumplist:isbumplist
|
|
|
|
if (obj != undefined) and (not isRefObj obj) and (not isInternalRef obj) and (mat != undefined) do
|
|
(
|
|
if classof mat == MultiMaterial then (
|
|
--print "multi"
|
|
|
|
matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
|
|
for i = 1 to matlist.count do
|
|
(
|
|
local matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if (matidx != 0) do
|
|
(
|
|
RsGetTexMapsFromMaterial obj mat.materiallist[matidx] texmaplist maxsizelist isbumplist
|
|
)
|
|
)
|
|
)
|
|
else if classof mat == XRef_Material then (
|
|
|
|
RsGetTexMapsFromMaterial obj (mat.getsrcitem()) texmaplist maxsizelist isbumplist
|
|
)
|
|
else if classof mat == Standardmaterial then (
|
|
|
|
--print "standard"
|
|
|
|
diffuseName = ""
|
|
doAlpha = false
|
|
|
|
subTexMap = getSubTexmap mat 1
|
|
|
|
if subTexMap == undefined then (
|
|
|
|
doAlpha = true
|
|
subTexMap = getSubTexmap mat 2
|
|
)
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if ( ( undefined != subTexMap.filename ) and ( "" != subTexMap.filename ) ) do
|
|
(
|
|
texmapname = toLower(subTexMap.filename)
|
|
|
|
diffuseName = texmapname
|
|
)
|
|
|
|
if doAlpha do
|
|
(
|
|
subTexMap = getSubTexmap mat 7
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if ( ( undefined != subTexMap.filename ) and ( "" != subTexMap.filename ) ) do
|
|
(
|
|
texmapname = toLower(subTexMap.filename)
|
|
|
|
diffuseName = diffuseName + "+" + texmapname
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if (diffuseName != "") do
|
|
(
|
|
diffuseName = RsMakeSafeTextureName(RsStripTexturePath diffuseName)
|
|
|
|
if finditem texmaplist diffuseName == 0 then (
|
|
|
|
--print diffuseName
|
|
--print RsDiffuseTexMaxSize
|
|
|
|
append texmaplist diffuseName
|
|
append maxsizelist RsDiffuseTexMaxSize
|
|
append isbumplist false
|
|
)
|
|
)
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do (
|
|
|
|
if (i != 2) and (i != 7) then (
|
|
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
if (isKindOf subTexMap Bitmaptexture) and ( undefined != subTexMap.filename ) and ( "" != subTexMap.filename ) do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath (subTexMap.filename))
|
|
|
|
if (finditem texmaplist texmapname == 0) then
|
|
(
|
|
append texmaplist texmapname
|
|
append maxsizelist RsOtherTexMaxSize
|
|
|
|
if (i == 9) then
|
|
(
|
|
append isbumplist true
|
|
)
|
|
else
|
|
(
|
|
append isbumplist false
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
) else if classof mat == Rage_Shader then (
|
|
|
|
--print "rage"
|
|
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
if RstGetIsAlphaShader mat then (
|
|
|
|
numTexMap = numTexMap / 2
|
|
)
|
|
|
|
for i = 1 to numTexMap do (
|
|
|
|
texmapname = ""
|
|
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) then
|
|
(
|
|
if ( ( undefined != subTexMap.filename ) and ( "" != subTexMap.filename ) ) then (
|
|
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath(subTexMap.filename))
|
|
)
|
|
|
|
if RstGetIsAlphaShader mat then (
|
|
|
|
local alphaTexMap = getSubTexmap mat (i + numTexMap)
|
|
|
|
if classof alphaTexMap == Bitmaptexture then (
|
|
|
|
if ( undefined != alphaTexMap.filename and "" != alphaTexMap.filename ) then (
|
|
|
|
texmapname += "+" + RsMakeSafeTextureName(RsStripTexturePath (alphaTexMap.filename))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else if (isKindOf subTexMap CompositeTexturemap) then
|
|
(
|
|
numMaps = getnumsubtexmaps subTexMap
|
|
|
|
for j = 1 to numMaps do (
|
|
|
|
subsubTexMap = getSubTexmap subTexMap j
|
|
|
|
if (isKindOf subsubTexMap Bitmaptexture) and ( undefined != subsubTexMap.filename ) and ( "" != subsubTexMap.filename ) do
|
|
(
|
|
if (j != 1) do
|
|
(
|
|
texmapname += ">"
|
|
)
|
|
|
|
texmapname += RsMakeSafeTextureName(RsStripTexturePath(subsubTexMap.filename))
|
|
)
|
|
)
|
|
)
|
|
|
|
if ( ( undefined != texmapname ) and ( "" != texmapname ) ) do
|
|
(
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
local texmaptype = RsGetTexMapNameFromRsShader mat i
|
|
local addMap = gRsIncTexmaps.isIncluded texmapname texmapType
|
|
|
|
if addMap do
|
|
(
|
|
--print texmapname
|
|
|
|
append texmaplist texmapname
|
|
|
|
if RsIsBumpMap texmaptype then (
|
|
|
|
append isbumplist true
|
|
) else (
|
|
|
|
append isbumplist false
|
|
)
|
|
|
|
if RsIsDiffuseMap texmaptype then (
|
|
|
|
--print RsDiffuseTexMaxSize
|
|
append maxsizelist RsDiffuseTexMaxSize
|
|
) else (
|
|
|
|
--print RsOtherTexMaxSize
|
|
append maxsizelist RsOtherTexMaxSize
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do (
|
|
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (classof subTexMap == Bitmaptexture) and (subTexMap.filename != "") do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(RsStripTexturePath (subTexMap.filename))
|
|
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
append texmaplist texmapname
|
|
append isbumplist false
|
|
|
|
texmapname = RsGetTexMapNameFromRsShader mat i
|
|
|
|
if RsIsDiffuseMap texmapname then
|
|
(
|
|
append maxsizelist RsDiffuseTexMaxSize
|
|
)
|
|
else
|
|
(
|
|
append maxsizelist RsOtherTexMaxSize
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by a material
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromMaterialNoStrip obj mat texmaplist maxsizelist isbumplist exemptionList:#() texmapobjlist:#() maptypelist:#() texturetemplatelist:#() materialpresetlist:#() =
|
|
(
|
|
if (isKindOf obj Col_Mesh) do return False
|
|
|
|
RsCheckForLighttextures obj texmaplist maxsizelist:maxsizelist isbumplist:isbumplist exemptionList:exemptionList texmapobjlist:texmapobjlist maptypelist:maptypelist texturetemplatelist:texturetemplatelist
|
|
|
|
if (not isRefObj obj) and (not isInternalRef obj) and (mat != undefined) do
|
|
(
|
|
case (classof mat) of
|
|
(
|
|
MultiMaterial:
|
|
(
|
|
matlist = #()
|
|
|
|
RsMatGetMapIdsUsedOnObject obj matlist
|
|
|
|
for i = 1 to matlist.count do
|
|
(
|
|
local matidx = finditem mat.materialIDList matlist[i]
|
|
|
|
if matidx != 0 do
|
|
(
|
|
RsGetTexMapsFromMaterialNoStrip obj mat.materiallist[matidx] texmaplist maxsizelist isbumplist exemptionList:exemptionList texmapobjlist:texmapobjlist maptypelist:maptypelist texturetemplatelist:texturetemplatelist materialpresetlist:materialpresetlist
|
|
)
|
|
)
|
|
)
|
|
XRef_Material:
|
|
(
|
|
RsGetTexMapsFromMaterialNoStrip obj (mat.getsrcitem()) texmaplist maxsizelist isbumplist exemptionList:exemptionList texmapobjlist:texmapobjlist maptypelist:maptypelist texturetemplatelist:texturetemplatelist materialpresetlist:materialpresetlist
|
|
|
|
)
|
|
Standardmaterial:
|
|
(
|
|
local diffuseName = ""
|
|
|
|
local doAlpha = false
|
|
local subTexMap = getSubTexmap mat 1
|
|
|
|
if (subTexMap == undefined) do
|
|
(
|
|
doAlpha = true
|
|
subTexMap = getSubTexmap mat 2
|
|
)
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if ( ( undefined != subTexMap.filename ) and ( "" != subTexMap.filename ) ) do
|
|
(
|
|
texmapname = toLower(subTexMap.filename)
|
|
|
|
diffuseName = texmapname
|
|
)
|
|
|
|
if doAlpha do
|
|
(
|
|
local alphaTexMap = getSubTexmap mat 7
|
|
|
|
if (isKindOf alphaTexMap Bitmaptexture) do
|
|
(
|
|
if ( ( undefined != alphaTexMap.filename ) and ( "" != alphaTexMap.filename ) ) do
|
|
(
|
|
texmapname = toLower(alphaTexMap.filename)
|
|
|
|
diffuseName = diffuseName + "+" + texmapname
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if (diffuseName != "") do
|
|
(
|
|
diffuseName = RsMakeSafeTextureName(diffuseName)
|
|
|
|
if (findItem texmaplist diffuseName == 0) do
|
|
(
|
|
-- format "Texture map: %\n" diffuseName
|
|
--print RsDiffuseTexMaxSize
|
|
|
|
append texmaplist diffuseName
|
|
append maptypelist "Diffuse"
|
|
append texmapobjlist subTexMap
|
|
append maxsizelist RsDiffuseTexMaxSize
|
|
append isbumplist false
|
|
append exemptionList false
|
|
append texturetemplatelist "Default"
|
|
)
|
|
)
|
|
|
|
local numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do
|
|
(
|
|
if (i != 2) and (i != 7) do
|
|
(
|
|
subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) do
|
|
(
|
|
if (undefined != subTexMap.filename) and ("" != subTexMap.filename) do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(subTexMap.filename)
|
|
|
|
if finditem texmaplist texmapname == 0 then (
|
|
|
|
append texmaplist texmapname
|
|
append texmapobjlist subTexMap
|
|
append maxsizelist RsOtherTexMaxSize
|
|
append exemptionList false
|
|
|
|
if i == 9 then (
|
|
|
|
append maptypelist "Bump Texture"
|
|
append isbumplist true
|
|
append texturetemplatelist "NormalMap"
|
|
) else (
|
|
|
|
append maptypelist "Default"
|
|
append isbumplist false
|
|
append texturetemplatelist "Default"
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
Rage_Shader:
|
|
(
|
|
numTexMap = getNumSubTexmaps mat
|
|
|
|
if RstGetIsAlphaShader mat do
|
|
(
|
|
numTexMap /=2
|
|
)
|
|
|
|
local materialPresetPath = RstGetMaterialPresetPath mat
|
|
if (materialPresetPath != undefined) do
|
|
(
|
|
materialPresetPath = (toLower materialPresetPath)
|
|
)
|
|
|
|
for i = 1 to numTexMap do
|
|
(
|
|
texmapname = ""
|
|
|
|
subTexMap = getSubTexmap mat i
|
|
local alphaTexMap = undefined
|
|
if RstGetIsAlphaShader mat then
|
|
alphaTexMap = getSubTexmap mat (i + numTexMap)
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
if (RstGetIsAlphaShader mat) and (undefined!=alphaTexMap) do
|
|
(
|
|
local requestshader = yesNoCancelBox "Distance map can NOT be used in shaders with separate alpha textures, since it creates its own one. Use another shader or leave alpha slot empty.\nYes: Auto fix by deleting alpha texture of shader.\nNo: Put shader in slot 24 and fix yourself."
|
|
if #yes==requestshader then
|
|
(
|
|
setSubTexmap mat (i + numTexMap) undefined
|
|
alphaTexMap = undefined
|
|
)
|
|
else if #no==requestshader then
|
|
meditmaterials[24] = mat
|
|
)
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
|
|
if (isKindOf subTexMap Bitmaptexture) then (
|
|
|
|
if ( ( undefined != subTexMap.filename ) and ( "" != subTexMap.filename ) ) then (
|
|
|
|
texmapname = RsMakeSafeTextureName(subTexMap.filename)
|
|
)
|
|
|
|
if RstGetIsAlphaShader mat then (
|
|
|
|
if classof alphaTexMap == Bitmaptexture then (
|
|
|
|
if ( ( undefined != alphaTexMap.filename ) and ( "" != alphaTexMap.filename ) ) then (
|
|
|
|
texmapname += ("+" + RsMakeSafeTextureName(alphaTexMap.filename))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else if (isKindOf subTexMap CompositeTexturemap) do (
|
|
|
|
numMaps = getnumsubtexmaps subTexMap
|
|
|
|
for j = 1 to numMaps do (
|
|
|
|
subsubTexMap = getSubTexmap subTexMap j
|
|
|
|
if classof subsubTexMap == Bitmaptexture then (
|
|
|
|
if ( ( undefined != subsubTexMap.filename ) and ( "" != subsubTexMap.filename ) ) then (
|
|
|
|
if j != 1 then (
|
|
|
|
texmapname += ">"
|
|
)
|
|
|
|
texmapname += RsMakeSafeTextureName(subsubTexMap.filename)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if texmapname != "" then (
|
|
idxTexMapName = finditem texmaplist texmapname
|
|
textureTemplateOrder = #( "Diffuse", "Normal", "Specular" )
|
|
|
|
alreadyInList = false
|
|
if idxTexMapName != 0 then alreadyInList = true
|
|
|
|
texmaptype = RsGetTexMapNameFromRsShader mat i
|
|
|
|
idxTex = RsGetTexMapIdForRstMtl mat i
|
|
-- This is nasty but is the only way to deal with materials that have had their
|
|
-- .fxc files deleted.
|
|
if idxTex == undefined then (
|
|
texturetemplate = "Default"
|
|
)
|
|
else (
|
|
texturetemplate = RstGetTextureTemplate mat idxTex
|
|
)
|
|
if texturetemplate == "" then texturetemplate = RstGetTextureTemplateRelative mat idxTex
|
|
|
|
local addMap = gRsIncTexmaps.isIncluded texmapName texmapType
|
|
|
|
if addMap then (
|
|
|
|
if ( not alreadyInList ) then
|
|
(
|
|
append texmaplist texmapname
|
|
append maptypelist texmaptype
|
|
append texmapobjlist subtexmap
|
|
|
|
if (materialPresetPath != undefined) do
|
|
(
|
|
append materialpresetlist materialPresetPath
|
|
)
|
|
|
|
--print ("ADDING : " + texturetemplate + " for :" + texmapname)
|
|
append texturetemplatelist texturetemplate
|
|
|
|
if RsIsBumpMap texmaptype then (
|
|
|
|
append isbumplist true
|
|
) else (
|
|
|
|
append isbumplist false
|
|
)
|
|
|
|
if RsIsResizeExempt subTexMap texmaptype mat then (
|
|
|
|
append exemptionList true
|
|
) else (
|
|
|
|
append exemptionList false
|
|
)
|
|
|
|
if RsIsDiffuseMap texmaptype then (
|
|
|
|
append maxsizelist RsDiffuseTexMaxSize
|
|
) else (
|
|
|
|
append maxsizelist RsOtherTexMaxSize
|
|
)
|
|
)
|
|
-- Already in list so check if the priority of this type is higher
|
|
-- than the value already in the list, and replace if so
|
|
else
|
|
(
|
|
-- Template already in list
|
|
idxCurrentTemplate = findItem textureTemplateOrder texturetemplatelist[idxTexMapName]
|
|
-- Template being checked
|
|
idxThisTemplate = findItem textureTemplateOrder texturetemplate
|
|
--format "Current: %\tThis: %\n" texturetemplatelist[idxTexMapName] texturetemplate
|
|
--format "idxCurrent: %\t idxThis: %\n" idxCurrentTemplate idxThisTemplate
|
|
|
|
-- If this template isn't found in the list then it'll be 0, but is really
|
|
-- lowest priority
|
|
if ( idxThisTemplate != 0 and (idxThisTemplate < idxCurrentTemplate) ) then
|
|
(
|
|
texmaplist[idxTexMapName] = texmapname
|
|
maptypelist[idxTexMapName] = texmaptype
|
|
texmapobjlist[idxTexMapName] = subtexmap
|
|
|
|
--print ("CHANGING to : " + texturetemplate + " for :" + texmapname)
|
|
texturetemplatelist[idxTexMapName] = texturetemplate
|
|
|
|
if RsIsDiffuseMap texmaptype then (
|
|
|
|
maxsizelist[idxTexMapName] = RsDiffuseTexMaxSize
|
|
) else (
|
|
|
|
maxsizelist[idxTexMapName] = RsOtherTexMaxSize
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
Default:
|
|
(
|
|
local numTexMap = getNumSubTexmaps mat
|
|
|
|
for i = 1 to numTexMap do
|
|
(
|
|
local subTexMap = getSubTexmap mat i
|
|
|
|
if (isKindOf subTexMap DistanceAlphaMap) do
|
|
(
|
|
--print "validation check 0"
|
|
subTexMap = RsGetDistanceAlphaMapResultMap subTexMap
|
|
)
|
|
if (isKindOf subTexMap Bitmaptexture) and (subTexMap.filename != "") do
|
|
(
|
|
texmapname = RsMakeSafeTextureName(subTexMap.filename)
|
|
|
|
if (finditem texmaplist texmapname == 0) do
|
|
(
|
|
--print texmapname
|
|
|
|
append texmaplist texmapname
|
|
append texmapobjlist subtexmap
|
|
append isbumplist false
|
|
append exemptionList false
|
|
|
|
if (materialPresetPath != undefined) do
|
|
(
|
|
append materialpresetlist materialPresetPath
|
|
)
|
|
|
|
idxTex = RsGetTexMapIdForRstMtl mat i
|
|
|
|
texmaptype = RsGetTexMapNameFromRsShader mat i
|
|
texturetemplate = RstGetTextureTemplate mat idxTex
|
|
if texturetemplate == "" then texturetemplate = RstGetTextureTemplateRelative mat idxTex
|
|
|
|
append maptypelist texmaptype
|
|
append texturetemplatelist texturetemplate
|
|
|
|
if RsIsDiffuseMap texmaptype then
|
|
(
|
|
--print RsDiffuseTexMaxSize
|
|
append maxsizelist RsDiffuseTexMaxSize
|
|
)
|
|
else
|
|
(
|
|
--print RsOtherTexMaxSize
|
|
append maxsizelist RsOtherTexMaxSize
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
return True
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- takes a texmaplist and strips the paths in it
|
|
----------------------------------------------------------------------------------------
|
|
fn RsStripPaths texNameList =
|
|
(
|
|
for i = 1 to texNameList.count do
|
|
(
|
|
texNameList[i] = RsStripTexturePath texNameList[i]
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromObjWithMapsRec obj texmaplist bitmaplist incID:-1 =
|
|
(
|
|
if (obj == undefined) do return #()
|
|
|
|
RsGetTexMapsFromMaterialWithMap obj obj.material texmaplist bitmaplist incID:incID
|
|
|
|
for childobj in obj.children do (
|
|
RsGetTexMapsFromObjWithMapsRec childobj texmaplist bitmaplist incID:incID
|
|
)
|
|
|
|
if ( RsLodDrawable_HasLowerDetailModel obj ) then
|
|
(
|
|
local ldobj = ( RsLodDrawable_GetLowerDetailModel obj )
|
|
-- format "LD Model: RsGetTexMapsFromObjWithMapsRec %\n" ldobj
|
|
RsGetTexMapsFromObjWithMapsRec ldobj texmaplist bitmaplist incID:incID
|
|
)
|
|
|
|
return texmaplist
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- Fills texmaplist with the texture maps used by an object
|
|
-- If 'id' is used, only texmaps with that matId are returned
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromObjWithMaps obj texmaplist bitmaplist id:-1 =
|
|
(
|
|
RsGetTexMapsFromObjWithMapsRec obj texmaplist bitmaplist incID:id
|
|
|
|
RsStripPaths texmaplist
|
|
|
|
return texmaplist
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromObjRec obj texmaplist maxsizelist isbumplist = (
|
|
|
|
if obj != undefined then (
|
|
|
|
RsGetTexMapsFromMaterial obj obj.material texmaplist maxsizelist isbumplist
|
|
|
|
for childobj in obj.children do (
|
|
|
|
RsGetTexMapsFromObjRec childobj texmaplist maxsizelist isbumplist
|
|
)
|
|
|
|
if ( RsLodDrawable_HasLowerDetailModel obj ) then
|
|
(
|
|
local ldobj = ( RsLodDrawable_GetLowerDetailModel obj )
|
|
--format "LD Model: RsGetTexMapsFromObjRec %\n" ldobj
|
|
RsGetTexMapsFromObjRec ldobj texmaplist maxsizelist isbumplist
|
|
|
|
)
|
|
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromObj obj texmaplist maxsizelist isbumplist = (
|
|
|
|
RsGetTexMapsFromObjRec obj texmaplist maxsizelist isbumplist
|
|
|
|
RsStripPaths texmaplist
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by an object
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsFromObjNoStrip obj texmaplist maxsizelist isbumplist exemptionList:#() texmapobjlist:#() maptypelist:#() texturetemplatelist:#() materialpresetlist:#() =
|
|
(
|
|
gRsCallCountRsGetTexMapsFromObjNoStrip += 1
|
|
RsGetTexMapsFromMaterialNoStrip obj obj.material texmaplist maxsizelist isbumplist exemptionList:exemptionList texmapobjlist:texmapobjlist maptypelist:maptypelist texturetemplatelist:texturetemplatelist materialpresetlist:materialpresetlist
|
|
|
|
for childobj in obj.children do
|
|
(
|
|
RsGetTexMapsFromObjNoStrip childobj texmaplist maxsizelist isbumplist exemptionList:exemptionList texmapobjlist:texmapobjlist maptypelist:maptypelist texturetemplatelist:texturetemplatelist materialpresetlist:materialpresetlist
|
|
)
|
|
|
|
if ( RsLodDrawable_HasLowerDetailModel obj ) then
|
|
(
|
|
local ldobj = ( RsLodDrawable_GetLowerDetailModel obj )
|
|
--format "LD Model: RsGetTexMapsFromObjNoStrip %\n" ldobj
|
|
RsGetTexMapsFromObjNoStrip ldobj texmaplist maxsizelist isbumplist exemptionList:exemptionList texmapobjlist:texmapobjlist maptypelist:maptypelist texturetemplatelist:texturetemplatelist materialpresetlist:materialpresetlist
|
|
)
|
|
|
|
return texmaplist
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsMergeTextureUsage texmaplist texmaptypelist texturetemplatelist maxsizelist isbumplist usagelist exemptionlist objtexmaplist objtexmaptypelist objmaxsizelist objisbumplist infiniteusage objexemptionlist objtexturetemplatelist =
|
|
(
|
|
for i = 1 to objtexmaplist.count do
|
|
(
|
|
objtexmap = objtexmaplist[i]
|
|
isTintPalette = RsIsTintPalette objtexmaptypelist[i] -- B* 990857 - tint palettes are never considered 'infinite usage'
|
|
|
|
idxFound = finditem texmaplist objtexmap
|
|
|
|
if (idxFound == 0) then
|
|
(
|
|
append texmaplist objtexmap
|
|
append texmaptypelist objtexmaptypelist[i]
|
|
append maxsizelist objmaxsizelist[i]
|
|
append isbumplist objisbumplist[i]
|
|
append exemptionlist objexemptionlist[i]
|
|
append texturetemplatelist objtexturetemplatelist[i]
|
|
|
|
if (infiniteusage and (not isTintPalette)) then
|
|
(
|
|
append usagelist -1
|
|
)
|
|
else
|
|
(
|
|
append usagelist 1
|
|
)
|
|
)
|
|
else
|
|
(
|
|
if ( (infiniteusage and (not isTintPalette)) or usagelist[idxFound] == -1 ) then
|
|
(
|
|
usagelist[idxFound] = -1
|
|
)
|
|
else
|
|
(
|
|
-- Tint palettes are never to go in TXDs.
|
|
if (not isTintPalette) then
|
|
(
|
|
usagelist[idxFound] = usagelist[idxFound] + 1
|
|
)
|
|
else
|
|
(
|
|
usagelist[idxFound] = 1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsIsTXDUsedOnLod txdname srcobjlist:rootnode.children =
|
|
(
|
|
local idxTXD = getAttrIndex "Gta Object" "TXD"
|
|
|
|
local allObjs = #()
|
|
RsGetMapObjects srcObjList allObjs
|
|
|
|
local retVal = False
|
|
|
|
for obj in allObjs while (not retVal) do
|
|
(
|
|
if (getattrclass obj == "Gta Object") and (not isRefObj obj) and (not isInternalRef obj) do
|
|
(
|
|
retVal = ((matchPattern (getattr obj idxTXD) pattern:txdname) and (::RsIsAnyLOD obj))
|
|
)
|
|
)
|
|
|
|
return retVal
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by all objects with specified txd
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsByTxdNameNoStrip texmaplist maxsizelist isbumplist usagelist txdname srcobjlist: isCutsceneObject:false exemptionlist:#() texmaptypelist:#() texturetemplatelist:#() materialpresetlist:#() heavy_texture_logging:False =
|
|
(
|
|
txdname = toLower txdname
|
|
idxTXD = getattrindex "Gta Object" "TXD"
|
|
|
|
if (srcObjList == unsupplied) do
|
|
(
|
|
srcObjList = #()
|
|
join srcObjList rootnode.children
|
|
)
|
|
|
|
local allobjs = #()
|
|
|
|
RsGetMapObjects srcobjlist allobjs isCutsceneObject:isCutsceneObject
|
|
|
|
local usedCount = 0
|
|
|
|
for obj in allobjs do
|
|
(
|
|
if (isKindOf obj Gta_MILO) then
|
|
(
|
|
for childobj in obj.children do
|
|
(
|
|
if (not isRefObj childobj) and (not isInternalRef childobj) and (getattrclass childobj == "Gta Object") do
|
|
(
|
|
if (matchPattern (getattr childobj idxTXD) pattern:txdname) do
|
|
(
|
|
local objtexmaplist = #()
|
|
local objmaxsizelist = #()
|
|
local objisbumplist = #()
|
|
local objexemptionlist = #()
|
|
local objmaptypelist = #()
|
|
local objtexturetemplatelist = #()
|
|
|
|
RsGetTexMapsFromObjNoStrip childobj objtexmaplist objmaxsizelist objisbumplist exemptionlist:objexemptionlist maptypelist:objmaptypelist texturetemplatelist:objtexturetemplatelist materialpresetlist:materialpresetlist
|
|
RsMergeTextureUsage texmaplist texmaptypelist texturetemplatelist maxsizelist isbumplist usagelist exemptionlist objtexmaplist objmaptypelist objmaxsizelist objisbumplist false objexemptionlist objtexturetemplatelist
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
if (not isRefObj obj) and (not isInternalRef obj) and (getattrclass obj == "Gta Object") do
|
|
(
|
|
if (matchPattern (getattr obj idxTXD) pattern:txdname) do
|
|
(
|
|
local objtexmaplist = #()
|
|
local objmaxsizelist = #()
|
|
local objisbumplist = #()
|
|
local objexemptionlist = #()
|
|
local objmaptypelist = #()
|
|
local objtexturetemplatelist = #()
|
|
|
|
infiniteUsage = false
|
|
|
|
if ( RsIsAnyLOD obj == true ) then infiniteUsage = true
|
|
|
|
RsGetTexMapsFromObjNoStrip obj objtexmaplist objmaxsizelist objisbumplist exemptionlist:objexemptionlist maptypelist:objmaptypelist texturetemplatelist:objtexturetemplatelist materialpresetlist:materialpresetlist
|
|
|
|
if (heavy_texture_logging) do
|
|
(
|
|
format "************************************\n"
|
|
format "* after RsGetTexMapsFromObjNoStrip\n"
|
|
format "************************************\n"
|
|
format "obj.name: %\n" obj.name
|
|
format "infiniteUsage: %\n" infiniteUsage
|
|
format "objtexmaplist.count: %\n" objtexmaplist.count
|
|
for item in objtexmaplist do format " item: %\n" item
|
|
format "objmaxsizelist.count: %\n" objmaxsizelist.count
|
|
for item in objmaxsizelist do format " item: %\n" item
|
|
format "objisbumplist.count: %\n" objisbumplist.count
|
|
for item in objisbumplist do format " item: %\n" item
|
|
format "objexemptionlist.count: %\n" objexemptionlist.count
|
|
for item in objexemptionlist do format " item: %\n" item
|
|
format "objmaptypelist.count: %\n" objmaptypelist.count
|
|
for item in objmaptypelist do format " item: %\n" item
|
|
format "objtexturetemplatelist.count: %\n" objtexturetemplatelist.count
|
|
for item in objtexturetemplatelist do format " item: %\n" item
|
|
format "************************************\n"
|
|
)
|
|
|
|
RsMergeTextureUsage texmaplist texmaptypelist texturetemplatelist maxsizelist isbumplist usagelist exemptionlist objtexmaplist objmaptypelist objmaxsizelist objisbumplist infiniteUsage objexemptionlist objtexturetemplatelist
|
|
|
|
if (heavy_texture_logging) do
|
|
(
|
|
format "************************************\n"
|
|
format "* after RsMergeTextureUsage\n"
|
|
format "************************************\n"
|
|
format "texmaplist.count: %\n" texmaplist.count
|
|
for item in texmaplist do format " item: %\n" item
|
|
format "texmaptypelist.count: %\n" texmaptypelist.count
|
|
for item in texmaptypelist do format " item: %\n" item
|
|
format "texturetemplatelist.count: %\n" texturetemplatelist.count
|
|
for item in texturetemplatelist do format " item: %\n" item
|
|
format "maxsizelist.count: %\n" maxsizelist.count
|
|
for item in maxsizelist do format " item: %\n" item
|
|
format "isbumplist.count: %\n" isbumplist.count
|
|
for item in isbumplist do format " item: %\n" item
|
|
format "usagelist.count: %\n" usagelist.count
|
|
for item in usagelist do format " item: %\n" item
|
|
format "exemptionlist.count: %\n" exemptionlist.count
|
|
for item in exemptionlist do format " item: %\n" item
|
|
format "************************************\n"
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
-- Get texmaps for root-bone (if obj has one) to collect light-textures for a skinned object:
|
|
local skelObj = rexGetSkinRootBone obj
|
|
if (skelObj != undefined) do
|
|
(
|
|
local skel_texmaplist = #()
|
|
local skel_maxsizelist = #()
|
|
local skel_isbumplist = #()
|
|
local skel_exemptionlist = #()
|
|
local skel_maptypelist = #()
|
|
local skel_texturetemplatelist = #()
|
|
|
|
RsGetTexMapsFromObjNoStrip skelObj \
|
|
skel_texmaplist skel_maxsizelist skel_isbumplist exemptionlist:skel_exemptionlist maptypelist:skel_maptypelist texturetemplatelist:skel_texturetemplatelist materialpresetlist:materialpresetlist
|
|
RsMergeTextureUsage \
|
|
texmaplist texmaptypelist texturetemplatelist maxsizelist isbumplist usagelist exemptionlist \
|
|
skel_texmaplist skel_maptypelist skel_maxsizelist skel_isbumplist false skel_exemptionlist skel_texturetemplatelist
|
|
)
|
|
)
|
|
|
|
return texmaplist
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- fills texmaplist with the texture maps used by all objects with specified txd
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTexMapsByTxdName texmaplist maxsizelist isbumplist usagelist txdname srcobjlist:rootnode.children isCutsceneObject:false resizeexemptionlist:#() texmaptypelist:#() texturetemplatelist:#() texmaplistnostrip:#() = (
|
|
|
|
newtexmaplist = #()
|
|
newtexmaptypelist = #()
|
|
newmaxsizelist = #()
|
|
newisbumplist = #()
|
|
newusagelist = #()
|
|
newresizeexemptionlist = #()
|
|
newtexturetemplatelist = #()
|
|
|
|
RsGetTexMapsByTxdNameNoStrip newtexmaplist newmaxsizelist newisbumplist newusagelist txdname srcobjlist:srcobjlist isCutsceneObject:isCutsceneObject exemptionlist:newresizeexemptionlist texmaptypelist:newtexmaptypelist texturetemplatelist:newtexturetemplatelist
|
|
newtexmaplistnostrip = copy newtexmaplist #nomap
|
|
RsStripPaths newtexmaplist
|
|
|
|
-- we need to do this because there will be multiple entries if the same texture name
|
|
-- has been used from a different path or extension
|
|
|
|
for i = 1 to newtexmaplist.count do (
|
|
|
|
texmap = newtexmaplist[i]
|
|
|
|
idxFound = finditem texmaplist texmap
|
|
|
|
if idxFound == 0 then (
|
|
|
|
append texmaplist newtexmaplist[i]
|
|
append texmaptypelist newtexmaptypelist[i]
|
|
append maxsizelist newmaxsizelist[i]
|
|
append isbumplist newisbumplist[i]
|
|
append usagelist newusagelist[i]
|
|
append resizeexemptionlist newresizeexemptionlist[i]
|
|
append texturetemplatelist newtexturetemplatelist[i]
|
|
append texmaplistnostrip newtexmaplistnostrip[i]
|
|
|
|
) else if usagelist[idxFound] != -1 and newusagelist[i] != -1 then (
|
|
|
|
usagelist[idxFound] = usagelist[idxFound] + newusagelist[i]
|
|
) else if newusagelist[i] == -1 then (
|
|
|
|
usagelist[idxFound] = -1
|
|
)
|
|
)
|
|
|
|
return texmaplist
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTxdFromObject obj txdList: txdObjList: includeRefs:false
|
|
idxGroupTXD:(getattrindex "Gta Group" "TXD")
|
|
idxTXD:(getattrindex "Gta Object" "TXD")
|
|
idxDontExport:(GetAttrIndex "Gta Object" "Dont Export") =
|
|
(
|
|
local txd = unsupplied
|
|
|
|
case of
|
|
(
|
|
(includeRefs and (isRSref obj includeDelegates:true)):
|
|
(
|
|
txd = if (obj.refDef == undefined) then
|
|
(
|
|
"null"
|
|
)
|
|
else
|
|
(
|
|
if (obj.refDef.txd == undefined) do
|
|
(
|
|
RsRefFuncs.loadTxds #(obj.refDef)
|
|
)
|
|
|
|
toLower obj.refDef.txd
|
|
)
|
|
)
|
|
(includeRefs and isInternalRef obj):
|
|
(
|
|
local srcObj = getIRefSource obj
|
|
if (getattrclass srcObj == "Gta Object") do
|
|
(
|
|
txd = toLower (getattr srcObj idxTXD)
|
|
)
|
|
)
|
|
((not isInternalRef obj) and (not isRefObj obj) and (getattrclass obj == "Gta Object")):
|
|
(
|
|
valDontExport = getattr obj idxDontExport
|
|
|
|
if valDontExport == false do
|
|
(
|
|
txd = toLower (getattr obj idxTXD)
|
|
)
|
|
)
|
|
(isKindOf obj Container):
|
|
(
|
|
-- Iterate through container's children.
|
|
for child in obj.children do
|
|
(
|
|
RsGetTxdFromObject child txdList:txdList txdObjList:txdObjList includeRefs:includeRefs idxGroupTXD:idxGroupTXD idxTXD:idxTXD idxDontExport:idxDontExport
|
|
)
|
|
)
|
|
(isKindOf obj GtaGroup):
|
|
(
|
|
txd = toLower (getattr obj idxGroupTXD)
|
|
)
|
|
)
|
|
|
|
-- Don't add to lists if they're not being used:
|
|
if (txd == unsupplied) then
|
|
(
|
|
txd = undefined
|
|
)
|
|
else if (txdList != unsupplied) do
|
|
(
|
|
local idxTxd = finditem txdList txd
|
|
if (idxTxd == 0) do
|
|
(
|
|
append txdList txd
|
|
append txdObjList #()
|
|
idxTxd = txdList.count
|
|
)
|
|
append txdObjList[idxTxd] obj
|
|
)
|
|
|
|
return txd
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- get all the txd names for objList
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetTxdList objList txdList txdObjList includeRefs:false sorted:false
|
|
idxGroupTXD:(getattrindex "Gta Group" "TXD")
|
|
idxTXD:(getattrindex "Gta Object" "TXD")
|
|
idxDontExport:(GetAttrIndex "Gta Object" "Dont Export") =
|
|
(
|
|
|
|
local RsGetTxdListMsg = ("RsGetTxdList count:(" + (objList.count as string) + ")")
|
|
gRsUlog.ProfileStart RsGetTxdListMsg
|
|
|
|
|
|
|
|
-- Pre-load RsRef txd-data:
|
|
if includeRefs do
|
|
(
|
|
-- Flatten obj-list:
|
|
local flatObjsList = for obj in objList collect obj
|
|
|
|
local objNum = 0
|
|
while objNum < flatObjsList.count do
|
|
(
|
|
objNum += 1
|
|
join flatObjsList flatObjsList[objNum].children
|
|
)
|
|
|
|
local refDefs = for obj in flatObjsList where (isRSref obj includeDelegates:true) and (obj.refDef != undefined) collect obj.refDef
|
|
RsRefFuncs.loadTxds (makeUniqueArray refDefs)
|
|
)
|
|
|
|
for obj in objlist do
|
|
(
|
|
case classof obj of
|
|
(
|
|
Gta_MILO:
|
|
(
|
|
for childObj in obj.children do
|
|
(
|
|
if classof childobj == GtaMloRoom then
|
|
(
|
|
for actualObj in childobj.children do
|
|
(
|
|
RsGetTxdFromObject actualObj txdList:txdList txdObjList:txdObjList includeRefs:includeRefs idxGroupTXD:idxGroupTXD idxTXD:idxTXD idxDontExport:idxDontExport
|
|
)
|
|
)
|
|
else
|
|
(
|
|
RsGetTxdFromObject childObj txdList:txdList txdObjList:txdObjList includeRefs:includeRefs idxGroupTXD:idxGroupTXD idxTXD:idxTXD idxDontExport:idxDontExport
|
|
)
|
|
)
|
|
)
|
|
Default:
|
|
(
|
|
RsGetTxdFromObject obj txdList:txdList txdObjList:txdObjList includeRefs:includeRefs idxGroupTXD:idxGroupTXD idxTXD:idxTXD idxDontExport:idxDontExport
|
|
)
|
|
)
|
|
)
|
|
|
|
local nulltxdsmsg = "Removing Null TXDs"
|
|
gRsUlog.ProfileStart nulltxdsmsg
|
|
|
|
-- Remove any null txds:
|
|
local foundNull = true
|
|
while foundNull do
|
|
(
|
|
foundNull = false
|
|
|
|
local idxItem = finditem txdList "null"
|
|
if idxItem != 0 then
|
|
(
|
|
foundNull = true
|
|
deleteItem txdList idxItem
|
|
deleteItem txdObjList idxItem
|
|
)
|
|
)
|
|
|
|
gRsUlog.ProfileEnd context:nulltxdsmsg
|
|
|
|
local sortTxdsMsg = "Sorting Txds"
|
|
gRsUlog.ProfileStart sortTxdsMsg
|
|
-- Sort txds/objs alphabetically:
|
|
if sorted do
|
|
(
|
|
-- Staple object-lists to txds:
|
|
local sortList = for n = 1 to txdList.count collect (dataPair txd:txdList[n] objs:txdObjList[n])
|
|
|
|
-- Sort list:
|
|
fn txdSorter v1 v2 = (striCmp v1.txd v2.txd)
|
|
qsort sortList txdSorter
|
|
|
|
-- Replace previous list-contents with sorted items:
|
|
txdList.count = 0
|
|
txdObjList.count = 0
|
|
join txdList (for item in sortList collect item.txd)
|
|
join txdObjList (for item in sortList collect item.objs)
|
|
)
|
|
gRsUlog.ProfileEnd context:sortTxdsMsg
|
|
|
|
gRsUlog.ProfileEnd context:RsGetTxdListMsg
|
|
return txdList
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- get all the txd names in the scene
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetSceneTxdList includeRefs:false =
|
|
(
|
|
local txdList = #()
|
|
RsGetTxdList rootnode.children txdlist #() includeRefs:includeRefs
|
|
return txdList
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
-- get all the txd names in the scene
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetSortedTxdList objlist txdlist includeRefs:false = (
|
|
|
|
txdobjlist = #()
|
|
|
|
RsGetTxdList objlist txdlist txdobjlist includeRefs:includeRefs
|
|
|
|
sort txdlist
|
|
)
|
|
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsStdMatIsMapUsedByObject obj mapidx = (
|
|
|
|
retval = false
|
|
|
|
objmat = obj.material
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == XRef_Material then (
|
|
|
|
objmat = objmat.getsrcitem()
|
|
)
|
|
|
|
if classof objmat == Standardmaterial then (
|
|
|
|
if objmat.mapEnables[mapidx] == true then (
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
else if classof objmat == Multimaterial then (
|
|
|
|
mapList = #()
|
|
RsMatGetMapIdsUsedOnObject obj mapList
|
|
|
|
for i = 1 to objmat.materialList.count do (
|
|
|
|
id = objmat.materialIDList[i]
|
|
|
|
if retval == false and finditem mapList id != 0 then (
|
|
|
|
mat = objmat.materialList[i]
|
|
|
|
if classof mat == Standardmaterial then (
|
|
|
|
if mat.mapEnables[mapidx] == true then (
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsDoesObjUseShader obj shaderName = (
|
|
|
|
retval = false
|
|
|
|
if classof obj == Editable_Mesh or classof obj == Editable_Poly then (
|
|
|
|
objmat = obj.material
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == XRef_Material then (
|
|
|
|
objmat = objmat.getsrcitem()
|
|
)
|
|
)
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == Multimaterial then (
|
|
|
|
mapList = #()
|
|
RsMatGetMapIdsUsedOnObject obj mapList
|
|
--print "MapList: " + (mapList as string)
|
|
for i = 1 to objmat.materialList.count do (
|
|
|
|
if retval == false then (
|
|
|
|
id = objmat.materialIDList[i]
|
|
|
|
if finditem mapList id != 0 then (
|
|
|
|
mat = objmat.materialList[i]
|
|
|
|
if classof mat == Rage_Shader then (
|
|
|
|
if (RsRemoveExtension(RstGetShaderName mat)) == shaderName then (
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if classof objmat == Rage_Shader then (
|
|
|
|
if (RsRemoveExtension(RstGetShaderName objmat)) == shaderName then (
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
retval
|
|
)
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsGetObjFacesUsingShader obj shaderName faceidlistout = (
|
|
|
|
retval = false
|
|
|
|
if classof obj == Editable_Mesh or classof obj == Editable_Poly then (
|
|
|
|
objmat = obj.material
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == XRef_Material then (
|
|
|
|
objmat = objmat.getsrcitem()
|
|
)
|
|
)
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == Multimaterial then (
|
|
|
|
mapList = #()
|
|
polyCountList = #()
|
|
faceIDLists = #()
|
|
|
|
RsMatGetMapIdsUsedOnObjectWithCount obj mapList polycount:polyCountList faceidlists:faceIDLists
|
|
|
|
-- QUICKER WITH OUT THESE LINES
|
|
--format "mapList: % \n" (mapList as string)
|
|
--format "polyCountList: %\n" (polyCountList as string)
|
|
--format "faceidlists: %\n" (faceIDLists as string)
|
|
|
|
for i = 1 to objmat.materialList.count do (
|
|
|
|
id = objmat.materialIDList[i]
|
|
idxFound = finditem mapList id
|
|
|
|
if idxFound != 0 then (
|
|
|
|
mat = objmat.materialList[i]
|
|
|
|
if classof mat == Rage_Shader then (
|
|
|
|
if (RsRemoveExtension(RstGetShaderName mat)) == shaderName then (
|
|
|
|
for item in faceIDLists[idxFound] do
|
|
(
|
|
append faceidlistout item
|
|
)
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if classof objmat == Rage_Shader then (
|
|
|
|
if (RsRemoveExtension(RstGetShaderName objmat)) == shaderName then (
|
|
for face in obj.faces do append faceidlistout face.index
|
|
retval = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
retval
|
|
)
|
|
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsCheckIsAlphad obj = (
|
|
|
|
isAlpha = false
|
|
|
|
if classof obj == Editable_Mesh or classof obj == Editable_Poly then (
|
|
|
|
objmat = obj.material
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == XRef_Material then (
|
|
|
|
objmat = objmat.getsrcitem()
|
|
)
|
|
)
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == Multimaterial then (
|
|
|
|
mapList = #()
|
|
RsMatGetMapIdsUsedOnObject obj mapList
|
|
|
|
for i = 1 to objmat.materialList.count do (
|
|
|
|
id = objmat.materialIDList[i]
|
|
|
|
if finditem mapList id != 0 then (
|
|
|
|
mat = objmat.materialList[i]
|
|
|
|
if rexHasAlpha obj mat then (
|
|
|
|
isAlpha = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
else (
|
|
|
|
if rexHasAlpha obj objmat then (
|
|
|
|
isAlpha = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
isAlpha
|
|
)
|
|
|
|
|
|
----------------------------------------------------------------------------------------
|
|
--
|
|
----------------------------------------------------------------------------------------
|
|
fn RsDoesObjUseGlassShader obj =
|
|
(
|
|
local retVal = false
|
|
|
|
local shadersUsed = ::RsGetShaderListForObjects obj
|
|
|
|
for shaderName in shadersUsed while not retVal do
|
|
(
|
|
retVal = matchPattern shaderName pattern:"*_glass*"
|
|
)
|
|
|
|
retVal
|
|
)
|
|
|
|
fn GetCompositeFileName fileNameIn =
|
|
(
|
|
-- Sort Wierdness in SpeedTreeCad where sometimes
|
|
-- the compositefilename stored in the .spt file
|
|
-- will not have the ".tga" extension amd sometimes it will
|
|
|
|
strExt = substring fileNameIn (fileNameIn.count - 3) 4
|
|
if strExt == ".tga" then (
|
|
fileNameOut = fileNameIn
|
|
)
|
|
else (
|
|
fileNameOut = fileNameIn + ".tga"
|
|
)
|
|
return fileNameOut
|
|
)
|
|
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return whether the specified object uses the specified shader
|
|
--
|
|
-- This is an enhanced version of the RsDoesObjUseShader2 above as it also
|
|
-- considers Standard materials that can be converted to shaders.
|
|
--
|
|
-- [return] true iff object uses shader, false otherwise
|
|
---------------------------------------------------------------------------------
|
|
fn RsDoesObjUseShader2 obj shaderName = (
|
|
|
|
retval = false
|
|
|
|
if classof obj == Editable_Mesh or classof obj == Editable_Poly then (
|
|
|
|
objmat = obj.material
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == XRef_Material then (
|
|
|
|
objmat = objmat.getsrcitem()
|
|
)
|
|
)
|
|
|
|
if objmat != undefined then (
|
|
|
|
if classof objmat == Multimaterial then (
|
|
|
|
mapList = #()
|
|
RsMatGetMapIdsUsedOnObject obj mapList
|
|
|
|
for i = 1 to objmat.materialList.count do (
|
|
|
|
if retval == false then (
|
|
|
|
id = objmat.materialIDList[i]
|
|
|
|
if finditem mapList id != 0 then (
|
|
|
|
mat = objmat.materialList[i]
|
|
|
|
if classof mat == Rage_Shader then (
|
|
|
|
if (RsRemoveExtension(RstGetShaderName mat)) == shaderName then (
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
else if classof mat == Standardmaterial then (
|
|
|
|
-- Check materials shader equivalent (if available)
|
|
matShaderName = ( rexStdMatShaderName mat )
|
|
if ( String != classof matShaderName ) then
|
|
continue
|
|
|
|
if ( RsRemoveExtension( matShaderName ) == shaderName ) then (
|
|
|
|
retval = true
|
|
)
|
|
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
if classof objmat == Rage_Shader then (
|
|
|
|
if (RsRemoveExtension(RstGetShaderName objmat)) == shaderName then (
|
|
|
|
retval = true
|
|
)
|
|
)
|
|
else if classof objmat == Standardmaterial then (
|
|
|
|
-- Check materials shader equivalent (if available)
|
|
matShaderName = ( rexStdMatShaderName objmat )
|
|
if ( String != classof matShaderName ) then
|
|
continue
|
|
|
|
if ( RsRemoveExtension( matShaderName ) == shaderName ) then (
|
|
retval = true
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
retval
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return number of Rage Shader and Standard materials (and submaterials)
|
|
-- only Standard materials that can be converted to Rage Shaders are included.
|
|
--
|
|
-- [return] Number of Rage Shader supported materials in the scene
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetMaterialCount &numRageShaderMaterials &numShaderStandardMaterials &numStandardMaterials = (
|
|
|
|
numRageShaderMaterials = 0
|
|
numShaderStandardMaterials = 0
|
|
numStandardMaterials = 0
|
|
|
|
for mat in sceneMaterials do
|
|
(
|
|
if ( Rage_Shader == classof mat ) then
|
|
numRageShaderMaterials += 1
|
|
|
|
else if ( Standard == classof mat ) then
|
|
(
|
|
shaderName = ( rexStdMatShaderName mat )
|
|
if ( String == classof shaderName ) then
|
|
numShaderStandardMaterials += 1
|
|
else
|
|
numStandardMaterials += 1
|
|
)
|
|
|
|
else if ( Multimaterial == classof mat ) then
|
|
(
|
|
for submat in mat.materialList do
|
|
(
|
|
if ( Rage_Shader == classof submat ) then
|
|
numRageShaderMaterials += 1
|
|
else if ( Standard == classof mat ) then
|
|
(
|
|
shaderName = ( rexStdMatShaderName mat )
|
|
if ( String == classof shaderName ) then
|
|
numShaderStandardMaterials += 1
|
|
else
|
|
numStandardMaterials += 1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
true
|
|
)
|
|
|
|
-- Return list of shaders used by material:
|
|
fn RsGetShaderListForMat mat shaderList:#() =
|
|
(
|
|
case (classof mat) of
|
|
(
|
|
Rage_Shader:
|
|
(
|
|
appendIfUnique shaderList (RstGetShaderName mat)
|
|
)
|
|
Multimaterial:
|
|
(
|
|
for subMat in mat.materialList do
|
|
(
|
|
RsGetShaderListForMat subMat shaderList:shaderList
|
|
)
|
|
)
|
|
)
|
|
|
|
shaderList
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Returns list of available shaders
|
|
-- (lower-case, with path/extension removed)
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetShaderList =
|
|
(
|
|
if (RSshaderList == undefined) do
|
|
(
|
|
local ShaderPaths = RsFindFilesRecursive ((RsConfigGetCommonDir core:true) + "shaders/db/") #("*.sps", "*.mpt", "*.mps")
|
|
RSshaderList = for Filename in ShaderPaths collect (toLower (getFilenameFile Filename))
|
|
)
|
|
|
|
return RSshaderList
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return list of shaders in current scene
|
|
--
|
|
-- [return] Array of shader name strings (path and extension removed)
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetSceneShaderList =
|
|
(
|
|
shaderList = #()
|
|
|
|
for mat in sceneMaterials do
|
|
(
|
|
RsGetShaderListForMat mat shaderList:shaderList
|
|
)
|
|
|
|
sort shaderList
|
|
shaderList
|
|
)
|
|
|
|
-- Return list of shaders for a set of objects:
|
|
fn RsGetShaderListForObjects objs =
|
|
(
|
|
local shaderList = #()
|
|
|
|
for obj in objs do
|
|
(
|
|
local ObjMats = ::RsGetMaterialsOnObjFaces Obj
|
|
|
|
for Mat in ObjMats do
|
|
(
|
|
RsGetShaderListForMat Mat shaderList:shaderList
|
|
)
|
|
)
|
|
|
|
shaderList
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return list of Standard Materials for a set of objects
|
|
--
|
|
-- [in] objs List of objects to get list of Standard Materials for
|
|
-- [out] matList List of Standard Materials used by objs
|
|
-- [out[ parentList List of material's in matList's parents (per mat)
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetStdMatListForObjects objs &nameList &matList &parentList =
|
|
(
|
|
nameList = #()
|
|
matList = #()
|
|
parentList = #()
|
|
|
|
for o in objs do
|
|
(
|
|
|
|
if ( undefined == o.material ) then
|
|
continue
|
|
|
|
if ( StandardMaterial == classof o.material ) then
|
|
(
|
|
if ( 0 == findItem matList o.material ) then
|
|
(
|
|
append nameList o.name
|
|
append matList o.material
|
|
append parentList undefined
|
|
)
|
|
)
|
|
else if ( Multimaterial == classof o.material ) then
|
|
(
|
|
for subMat in o.material.materialList do
|
|
(
|
|
if ( StandardMaterial == classof subMat ) then
|
|
(
|
|
if ( 0 == findItem matList subMat ) then
|
|
(
|
|
append nameList o.name
|
|
append matList subMat
|
|
append parentList o.material
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return list of Rage Shader Materials for a set of objects
|
|
--
|
|
-- [in] objs List of objects to get list of Rage Shader Materials for
|
|
-- [out] matList List of Rage Shader Materials used by objs
|
|
-- [out] parentList List of material's in matList's parents (per mat)
|
|
-- [out] objectList Allows us to retrieve source object per mat
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetRageShaderMatListForObjects objs &matList &parentList objectList:#() =
|
|
(
|
|
matList = #()
|
|
parentList = #()
|
|
|
|
for o in objs do
|
|
(
|
|
|
|
if ( undefined == o.material ) then
|
|
continue
|
|
|
|
if ( Rage_Shader == classof o.material ) then
|
|
(
|
|
if ( 0 == findItem matList o.material ) then
|
|
(
|
|
append matList o.material
|
|
append parentList undefined
|
|
append objectList o
|
|
)
|
|
)
|
|
else if ( Multimaterial == classof o.material ) then
|
|
(
|
|
for subMat in o.material.materialList do
|
|
(
|
|
if ( Rage_Shader == classof subMat ) then
|
|
(
|
|
if ( 0 == findItem matList subMat ) then
|
|
(
|
|
append matList subMat
|
|
append parentList o.material
|
|
append objectList o
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return list of Rage Nitro Shader Materials for a set of objects
|
|
--
|
|
-- [in] objs List of objects to get list of Rage Shader Materials for
|
|
-- [out] matList List of Rage Shader Materials used by objs
|
|
-- [out] parentList List of material's in matList's parents (per mat)
|
|
-- [out] objectList Allows us to retrieve source object per mat
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetRageNitroShaderMatListForObjects objs &matList &parentList objectList:#() =
|
|
(
|
|
matList = #()
|
|
parentList = #()
|
|
|
|
for o in objs do
|
|
(
|
|
|
|
if ( undefined == o.material ) then
|
|
continue
|
|
|
|
if ( Rage_Nitro == classof o.material ) then
|
|
(
|
|
if ( 0 == findItem matList o.material ) then
|
|
(
|
|
append matList o.material
|
|
append parentList undefined
|
|
append objectList o
|
|
)
|
|
)
|
|
else if ( Multimaterial == classof o.material ) then
|
|
(
|
|
for subMat in o.material.materialList do
|
|
(
|
|
if ( Rage_Nitro == classof subMat ) then
|
|
(
|
|
if ( 0 == findItem matList subMat ) then
|
|
(
|
|
append matList subMat
|
|
append parentList o.material
|
|
append objectList o
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Return object shader usage counts for object list and shader list
|
|
--
|
|
-- [in] objs List of objects to get usage information for
|
|
-- [in] shaders List of shaders to get usage information for
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetObjectShaderCounts objs shaders =
|
|
(
|
|
shaderObjectCounts = #()
|
|
local shaderCount = shaders.count
|
|
|
|
-- Initialise shaderObjectCount entries
|
|
for sh in shaders do
|
|
append shaderObjectCounts 0
|
|
|
|
for i = 1 to shaderCount do
|
|
(
|
|
for o in objs do
|
|
(
|
|
if ( RsDoesObjUseShader2 o shaders[i] ) then
|
|
(
|
|
shaderObjectCounts[i] += 1
|
|
)
|
|
)
|
|
)
|
|
|
|
shaderObjectCounts
|
|
)
|
|
|
|
---------------------------------------------------------------------------------
|
|
-- Fetches object shader usage counts and object, materials lists using each shader
|
|
--
|
|
-- [in] objs List of objects to get usage information for
|
|
-- [in] shaders List of shaders to get usage information for
|
|
-- [out] shaderObjectLists Array of array of object references per shader
|
|
---------------------------------------------------------------------------------
|
|
fn RsGetObjectShaderUsageData objs shaders &shaderObjectLists &shaderMaterialLists =
|
|
(
|
|
-- Initialise parameter reference data
|
|
shaderObjectLists = #()
|
|
local shaderCount = shaders.count
|
|
|
|
-- Now iterate through shaders and objects to collect our usage data
|
|
for i = 1 to shaderCount do
|
|
(
|
|
shaderObjectList = #()
|
|
shaderMaterialList = #()
|
|
|
|
for o in objs do
|
|
(
|
|
if ( RsDoesObjUseShader2 o shaders[i] ) then
|
|
(
|
|
append shaderObjectList o
|
|
|
|
if ( Multimaterial == classof o.material ) then
|
|
(
|
|
for mat in o.material.materialList do
|
|
(
|
|
|
|
if ( Standard == classof mat ) then
|
|
(
|
|
shaderName = ( rexStdMatShaderName mat )
|
|
if ( ( undefined == shaderName ) or ( classof shaderName != String ) ) then
|
|
continue
|
|
|
|
if ( (RsRemoveExtension(shaderName)) == shaders[i] ) then
|
|
if ( 0 == findItem shaderMaterialList mat ) then
|
|
append shaderMaterialList mat
|
|
)
|
|
else if ( Rage_Shader == classof mat ) then
|
|
(
|
|
shaderName = ( RstGetShaderName mat )
|
|
|
|
if ( (RsRemoveExtension(shaderName)) == shaders[i] ) then
|
|
if ( 0 == findItem shaderMaterialList mat ) then
|
|
append shaderMaterialList mat
|
|
)
|
|
|
|
)
|
|
)
|
|
else if ( Standard == classof o.material ) then
|
|
(
|
|
shaderName = ( rexStdMatShaderName o.material )
|
|
if ( ( undefined == shaderName ) or ( classof shaderName != String ) ) then
|
|
continue
|
|
|
|
if ( (RsRemoveExtension(shaderName)) == shaders[i] ) then
|
|
if ( 0 == findItem shaderMaterialList o.material ) then
|
|
append shaderMaterialList o.material
|
|
)
|
|
else if ( Rage_Shader == classof o.material ) then
|
|
(
|
|
shaderName = ( RstGetShaderName o.material )
|
|
|
|
if ( (RsRemoveExtension(shaderName)) == shaders[i] ) then
|
|
if ( 0 == findItem shaderMaterialList o.material ) then
|
|
append shaderMaterialList o.material
|
|
)
|
|
|
|
)
|
|
)
|
|
|
|
append shaderObjectLists shaderObjectList
|
|
append shaderMaterialLists shaderMaterialList
|
|
)
|
|
|
|
true
|
|
)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- Is this a tree-billboard material?
|
|
---------------------------------------------------------------------------------------------------
|
|
fn RsIsBillboardMat mtl =
|
|
(
|
|
(isKindOf mtl Rage_Shader) and
|
|
(
|
|
local shadername = RstGetShaderName mtl
|
|
matchPattern shaderName pattern:"trees_lod2*"
|
|
)
|
|
)
|
|
|
|
-- True if obj has any billboard shaders:
|
|
fn RsFindTreeShader obj mtl treeShaderList: =
|
|
(
|
|
local retVal = False
|
|
|
|
case of
|
|
(
|
|
(isKindOf mtl MultiMaterial):
|
|
(
|
|
local matList = ::RsGetMaterialsOnObjFaces obj material:mtl
|
|
|
|
for subMat in matList do
|
|
(
|
|
local isTreeShader = RsFindTreeShader obj subMat treeShaderList:treeShaderList
|
|
if isTreeShader then
|
|
retVal = true
|
|
)
|
|
)
|
|
(RsIsBillboardMat mtl):
|
|
(
|
|
if unsupplied!=treeShaderList then
|
|
appendIfUnique treeShaderList mtl
|
|
retVal = True
|
|
)
|
|
)
|
|
|
|
return retVal
|
|
)
|
|
|
|
--
|
|
-- name: RsIsTreeBillboard
|
|
-- desc: Determine is the object is a tree-billboard (based on shader name).
|
|
--
|
|
fn RsIsTreeBillboard obj mat =
|
|
(
|
|
return RsFindTreeShader obj mat
|
|
)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- Swaps two materials
|
|
---------------------------------------------------------------------------------------------------
|
|
fn RsMatSwapSubMats multiSub mat1Idx mat2Idx =
|
|
(
|
|
if (isKindOf multiSub Multimaterial) then
|
|
(
|
|
-- Get positions of matIDs on material-list, just in case it's been reordered or has non-contigious ID-numbers:
|
|
local listPos1 = findItem multiSub.materialIDList mat1Idx
|
|
local listPos2 = findItem multiSub.materialIDList mat2Idx
|
|
|
|
-- Swap submaterials:
|
|
local tmp = multiSub.materialList[mat1Idx]
|
|
multiSub.materialList[mat1Idx] = multiSub.materialList[mat2Idx]
|
|
multiSub.materialList[mat2Idx] = tmp
|
|
|
|
-- Swap material-enableds:
|
|
local mat1Enabled = multiSub.mapEnabled[listPos1]
|
|
local mat2Enabled = multiSub.mapEnabled[listPos2]
|
|
multiSub.mapEnabled[mat1Idx] = mat2Enabled
|
|
multiSub.mapEnabled[mat2Idx] = mat1Enabled
|
|
|
|
-- Swap submaterial-labels: (not the actual materials' names)
|
|
local mat1Name = multiSub.names[listPos1]
|
|
local mat2Name = multiSub.names[listPos2]
|
|
multiSub.names[mat1Idx] = mat2Name
|
|
multiSub.names[mat2Idx] = mat1Name
|
|
|
|
for obj in geometry where (obj.mat == multiSub) do
|
|
(
|
|
local objClass = classOf obj
|
|
local objGetFaceMatID = case objClass of
|
|
(
|
|
Editable_Mesh:getFaceMatID
|
|
Editable_Poly:polyOp.getFaceMatID
|
|
)
|
|
local objSetFaceMatID = case objClass of
|
|
(
|
|
Editable_Mesh:setFaceMatID
|
|
Editable_Poly:polyOp.setFaceMatID
|
|
)
|
|
|
|
if (objGetFaceMatID != undefined) do
|
|
(
|
|
for faceNum = 1 to obj.numfaces do
|
|
(
|
|
case (objGetFaceMatID obj faceNum) of
|
|
(
|
|
mat1Idx:(objSetFaceMatID obj faceNum mat2Idx)
|
|
mat2Idx:(objSetFaceMatID obj faceNum mat1Idx)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
true
|
|
)
|
|
else false
|
|
)
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- Inserts new submaterial into multiSub
|
|
---------------------------------------------------------------------------------------------------
|
|
fn RsMatInsertSubMat multiSub newMatId newMat: =
|
|
(
|
|
if (isKindOf multiSub Multimaterial) then
|
|
(
|
|
if (newMat == unsupplied) do
|
|
(
|
|
local matClass = classOf multiSub.materialList[1]
|
|
newMat = createInstance matClass
|
|
)
|
|
|
|
-- Find the matID closest to newMatId, so that we can insert just before that
|
|
-- (I'm going through this rigmarole because the multimat may have been reordered or have non-contigious ID-numbers)
|
|
local insertAt = 1
|
|
local insertBeforeID = multiSub.numSubs
|
|
local getID
|
|
for n = 1 to multiSub.materialIDList.count do
|
|
(
|
|
getID = multiSub.materialIDList[n]
|
|
if (getID >= newMatId) do
|
|
(
|
|
if (getID < insertBeforeID) do
|
|
(
|
|
insertBeforeID = getID
|
|
insertAt = n
|
|
)
|
|
|
|
-- Bump up any IDs over newMatId:
|
|
multiSub.materialIDList[n] += 1
|
|
)
|
|
)
|
|
|
|
-- Insert the new material:
|
|
local newMatList = multiSub.materialList as array
|
|
local newMatIDList = multiSub.materialIDList as array
|
|
insertItem newMat newMatList insertAt
|
|
insertItem newMatId newMatIDList insertAt
|
|
multiSub.materialList = newMatList
|
|
multiSub.materialIDList = newMatIDList
|
|
|
|
-- Shuffle the submat enabled-values down the list:
|
|
for n = multiSub.materialList.count to (insertAt + 1) by -1 do
|
|
(
|
|
multiSub.mapEnabled[n] = multiSub.mapEnabled[n - 1]
|
|
)
|
|
|
|
local matObjs = for obj in geometry where (obj.mat == multiSub) collect obj
|
|
|
|
local curMatID
|
|
for obj in matObjs do
|
|
(
|
|
local objClass = classOf obj
|
|
local objGetFaceMatID = case objClass of
|
|
(
|
|
Editable_Mesh:getFaceMatID
|
|
Editable_Poly:polyOp.getFaceMatID
|
|
)
|
|
local objSetFaceMatID = case objClass of
|
|
(
|
|
Editable_Mesh:setFaceMatID
|
|
Editable_Poly:polyOp.setFaceMatID
|
|
)
|
|
|
|
if (objGetFaceMatID != undefined) do
|
|
(
|
|
for faceNum = 1 to obj.numfaces do
|
|
(
|
|
curMatID = objGetFaceMatID obj faceNum
|
|
if (curMatID >= newMatId) do
|
|
(
|
|
objSetFaceMatID obj faceNum (curMatID + 1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
true
|
|
)
|
|
else false
|
|
)
|
|
|
|
|
|
-- Returns list of defined texmaps for a given object/material/texmap:
|
|
fn RsGetMaterialTexMaps item texMaps:#() =
|
|
(
|
|
-- Recurse through given objects' materials and lightmaps:
|
|
if (isValidNode item) do
|
|
(
|
|
-- Get materials from object:
|
|
if (isProperty item #material) do
|
|
(
|
|
RsGetMaterialTexMaps item.material texMaps:texMaps
|
|
)
|
|
|
|
-- Get lightmap from light:
|
|
(
|
|
local lightShadowMap = undefined
|
|
|
|
if (isProperty item #delegate) do
|
|
(
|
|
item = item.delegate
|
|
)
|
|
|
|
if (isProperty item #shadowProjectorMap) do
|
|
(
|
|
lightShadowMap = item.shadowProjectorMap
|
|
)
|
|
|
|
if (lightShadowMap != undefined) do
|
|
(
|
|
RsGetMaterialTexMaps lightShadowMap texMaps:texMaps
|
|
)
|
|
)
|
|
|
|
return texMaps
|
|
)
|
|
|
|
-- Recurse through all sub-materials/textures:
|
|
case (classOf item) of
|
|
(
|
|
-- Materials:
|
|
MultiMaterial:
|
|
(
|
|
-- Recurse through submaterials:
|
|
for subMat in item.materialList do
|
|
(
|
|
RsGetMaterialTexMaps subMat texMaps:texMaps
|
|
)
|
|
)
|
|
CompositeMaterial:
|
|
(
|
|
-- Recurse through submaterials:
|
|
for subMat in item.materialList do
|
|
(
|
|
RsGetMaterialTexMaps subMat texMaps:texMaps
|
|
)
|
|
)
|
|
XRef_Material:
|
|
(
|
|
-- Recurse to reffed material:
|
|
RsGetMaterialTexMaps (item.getsrcitem()) texMaps:texMaps
|
|
)
|
|
Blend:
|
|
(
|
|
RsGetMaterialTexMaps item.map1 texMaps:texMaps
|
|
RsGetMaterialTexMaps item.map2 texMaps:texMaps
|
|
)
|
|
DoubleSided:
|
|
(
|
|
RsGetMaterialTexMaps item.material1 texMaps:texMaps
|
|
RsGetMaterialTexMaps item.material2 texMaps:texMaps
|
|
)
|
|
Shellac:
|
|
(
|
|
RsGetMaterialTexMaps item.shellacmtl1 texMaps:texMaps
|
|
RsGetMaterialTexMaps item.shellacmtl2 texMaps:texMaps
|
|
)
|
|
TopBottom:
|
|
(
|
|
RsGetMaterialTexMaps item.topMaterial texMaps:texMaps
|
|
RsGetMaterialTexMaps item.bottomMaterial texMaps:texMaps
|
|
)
|
|
|
|
-- Texturemaps:
|
|
Bitmaptexture:
|
|
(
|
|
-------------------------------------------------------------------------
|
|
-- Here's where the texturemaps are actually collected: --
|
|
-------------------------------------------------------------------------
|
|
if (item.filename != undefined) and (item.filename != "") do
|
|
(
|
|
append texMaps item
|
|
)
|
|
)
|
|
CompositeTexturemap:
|
|
(
|
|
-- Recurse through sub-texmaps:
|
|
for n = 1 to (getNumSubTexmaps item) do
|
|
(
|
|
local texMap = getSubTexmap item n
|
|
RsGetMaterialTexMaps texMap texMaps:texMaps
|
|
)
|
|
)
|
|
DistanceAlphaMap:
|
|
(
|
|
-- Get proper texmap for DistanceAlphaMap:
|
|
local texMap = RsGetDistanceAlphaMapResultMap item
|
|
RsGetMaterialTexMaps texMap texMaps:texMaps
|
|
)
|
|
|
|
-- Ignore undefined materials/textureMaps
|
|
UndefinedClass:()
|
|
Default:
|
|
(
|
|
if (isKindOf item material) do
|
|
(
|
|
-- Recurse through material's texturemaps:
|
|
for n = 1 to (getNumSubTexmaps item) do
|
|
(
|
|
local texMap = getSubTexmap item n
|
|
RsGetMaterialTexMaps texMap texMaps:texMaps
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
return texMaps
|
|
)
|
|
|
|
-- Lists all texture-paths used by material/texturemap/object 'item'
|
|
fn RsGetMaterialTextures item textureList:#() =
|
|
(
|
|
local texMaps = RsGetMaterialTexMaps item
|
|
|
|
-- Make texMaps list only contain unique texmaps:
|
|
local texMaps = (makeUniqueArray texMaps)
|
|
|
|
-- Set textureList to unique array of non-undefined paths:
|
|
local newTexPaths = for texMap in texMaps collect texMap.filename
|
|
newTexPaths = for filename in newTexPaths where (filename != "") and (filename != undefined) collect (toLower filename)
|
|
|
|
-- Don't edit/uniquify textureList if we're not adding anything:
|
|
if (newTexPaths.count != 0) do
|
|
(
|
|
join textureList newTexPaths
|
|
newTexPaths = makeUniqueArray textureList
|
|
|
|
-- Replace textureList with ammended version of list:
|
|
textureList.count = 0
|
|
join textureList newTexPaths
|
|
)
|
|
|
|
return textureList
|
|
)
|
|
|
|
-- Get unique textureMap items used in scene:
|
|
fn RsGetSceneTexMaps =
|
|
(
|
|
local texMaps = #()
|
|
|
|
-- Get lightmaps from light-objects:
|
|
for obj in lights do
|
|
(
|
|
RsGetMaterialTexMaps obj texMaps:texMaps
|
|
)
|
|
|
|
-- Get texmaps from sceneMaterials:
|
|
local sceneMats = makeUniqueArray (for mat in sceneMaterials collect mat)
|
|
for mat in sceneMats do
|
|
(
|
|
RsGetMaterialTexMaps mat texMaps:texMaps
|
|
)
|
|
|
|
-- Make unique array:
|
|
texMaps = makeUniqueArray texMaps
|
|
|
|
return texMaps
|
|
)
|
|
|
|
-- Lists all texture-paths used on materials used in the scene.
|
|
-- (Materials don't have to actually be applied to objects)
|
|
fn RsGetSceneTextures =
|
|
(
|
|
local texMaps = RsGetSceneTexMaps()
|
|
|
|
local textureList = for texMap in texMaps collect (toLower texMap.filename)
|
|
textureList = makeUniqueArray textureList
|
|
|
|
return textureList
|
|
)
|
|
|
|
-- Perforce-syncs files in textureList to latest versions on Perforce, if they're under the texture-root:
|
|
fn RsP4syncTextures textureList =
|
|
(
|
|
-- Sync scene-textures if they're in Perforce. Force-syncs if they still don't exist locally after that sync.
|
|
::gRsPerforce.syncWithRetry textureList showProgress:true progressTitle:"P4 Sync Textures:" silent:true
|
|
)
|
|
|
|
-- Perforce-syncs all textures used in the scene:
|
|
fn RsP4syncSceneTextures =
|
|
(
|
|
RsP4syncTextures (RsGetSceneTextures())
|
|
)
|
|
|
|
-- Returns all materials actually used on an object, and optionally can pass those materials' face-lists by reference
|
|
fn RsGetMaterialsOnObjFaces obj material: materials:#() faceLists: mtlIdList:#() =
|
|
(
|
|
local objMat = if (material == unsupplied) then obj.material else material
|
|
if (classof objMat == XRef_Material) or isRefObj obj then
|
|
return materials
|
|
|
|
local getMesh = true
|
|
|
|
local doFaceLists = (isKindOf faceLists Array)
|
|
|
|
case of
|
|
(
|
|
((isKindOf obj editable_mesh) or (isKindOf obj trimesh)):
|
|
(
|
|
getMesh = false
|
|
)
|
|
(isKindOf obj col_mesh):
|
|
(
|
|
obj = getColMesh obj
|
|
getMesh = false
|
|
)
|
|
(isKindOf obj Editable_Poly):
|
|
(
|
|
if ((polyop.GetHasDeadStructs obj) > 0 ) do
|
|
(
|
|
polyOp.collapseDeadStructs obj
|
|
)
|
|
|
|
getMesh = false
|
|
)
|
|
)
|
|
|
|
if getMesh do
|
|
(
|
|
if (isProperty obj #mesh) AND (classof obj != Targetobject) then
|
|
(
|
|
obj = copy obj.mesh
|
|
)
|
|
else
|
|
(
|
|
return #()
|
|
)
|
|
)
|
|
if(obj == undefined) then return #()
|
|
|
|
local objGetFaceMatID = RsGetFaceMatIDFunc obj
|
|
|
|
local numFaces = getNumFaces obj
|
|
local objSubMatIndex = #()
|
|
|
|
local isMultiMat = isKindOf objMat Multimaterial
|
|
local matCount = if isMultiMat then objMat.numSubs else 1
|
|
|
|
-- collect list of the object's faces' matIDs, corrected
|
|
if isMultiMat then
|
|
(
|
|
local foundMatIds = #()
|
|
|
|
for faceNum = 1 to numFaces do
|
|
(
|
|
local matNum = objGetFaceMatID obj faceNum
|
|
|
|
-- Deal with matIDs that are higher than the material-count:
|
|
if (matNum > matCount) do
|
|
(
|
|
matNum = (mod matNum matCount) as integer
|
|
if (matNum == 0) do (matNum = matCount)
|
|
)
|
|
|
|
local findNum = foundMatIds[matNum]
|
|
|
|
if (findNum == undefined) do
|
|
(
|
|
local matIdNum = findItem objMat.materialIDList matNum
|
|
|
|
local newMat = if (matIdNum == 0) then undefined else objMat.materialList[matIdNum]
|
|
|
|
findNum = findItem materials newMat
|
|
|
|
if (findNum == 0) do
|
|
(
|
|
append materials newMat
|
|
if doFaceLists do
|
|
(
|
|
append faceLists #{}
|
|
)
|
|
append mtlIdList matNum
|
|
findNum = materials.count
|
|
)
|
|
)
|
|
|
|
if doFaceLists do
|
|
(
|
|
faceLists[findNum][faceNum] = true
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
-- Single-material objects are simpler to process
|
|
append materials objMat
|
|
if doFaceLists do
|
|
(
|
|
append faceLists #{1..obj.numFaces}
|
|
)
|
|
append mtlIdList 1
|
|
)
|
|
|
|
return materials
|
|
)
|
|
|
|
-- Return the submaterial that will be applied to an face with a particular matId
|
|
-- (taking into account non-multimaterials and out-of-range material values)
|
|
fn RsGetSubmatByMatId mat matId =
|
|
(
|
|
if (isKindOf mat MultiMaterial) then
|
|
(
|
|
-- Deal with out-of-range values:
|
|
local numSubs = mat.numSubs
|
|
matId = (mod matId numSubs) as integer
|
|
if (matId == 0) do matId = numSubs
|
|
|
|
local matIdx = findItem mat.materialIDList matId
|
|
|
|
if (matIdx == 0) then return undefined else mat.materialList[matIdx]
|
|
)
|
|
else
|
|
(
|
|
return mat
|
|
)
|
|
)
|
|
|
|
-- Returns the texturemap paths for materials used on objects in given map-containers:
|
|
fn RsGetMapTextures maps =
|
|
(
|
|
local textureList = #()
|
|
|
|
local checkObjs = #()
|
|
for map in maps do
|
|
(
|
|
local mapObjs = for obj in map.objects where (getattrclass obj == "Gta Object") collect obj
|
|
|
|
local refNames = #()
|
|
local uniqueObjs = #()
|
|
|
|
for obj in mapObjs do
|
|
(
|
|
case of
|
|
(
|
|
-- Only count one of each ref:
|
|
(isRSref obj includeDelegates:true):
|
|
(
|
|
if (appendIfUnique refNames obj.objectName) do
|
|
(
|
|
append uniqueObjs obj
|
|
)
|
|
)
|
|
-- Don't include internalrefs, as their parent-object should already be used:
|
|
(isRsInternalRef obj):()
|
|
default:
|
|
(
|
|
append uniqueObjs obj
|
|
)
|
|
)
|
|
)
|
|
|
|
join checkObjs uniqueObjs
|
|
)
|
|
|
|
-- Filter out further instances of objects:
|
|
checkObjs = ::RsGetInstGroupLeaders checkObjs
|
|
if (checkObjs.count != 0) do
|
|
(
|
|
pushPrompt "Collecting texture-paths..."
|
|
format "Collecting texture-paths...\n"
|
|
local timeStart = timestamp()
|
|
|
|
local matsUsed = #()
|
|
for obj in checkObjs do
|
|
(
|
|
local objMats = RsGetMaterialsOnObjFaces obj
|
|
join matsUsed objMats
|
|
)
|
|
|
|
for mat in (makeUniqueArray matsUsed) do
|
|
(
|
|
RsGetMaterialTextures mat textureList:textureList
|
|
)
|
|
|
|
popPrompt()
|
|
format "Time taken: %s\n" ((timestamp() - timeStart) / 1000.0)
|
|
)
|
|
|
|
return textureList
|
|
)
|
|
--RsGetMapTextures(RsMapGetMapContainers())
|
|
-- End of script
|