1293 lines
56 KiB
Plaintext
Executable File
1293 lines
56 KiB
Plaintext
Executable File
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- RSL_CollisionOps2Attribute
|
|
-- By Paul Truss
|
|
-- Senior Technical Artist
|
|
-- Rockstar Games London
|
|
-- 12/01/2011
|
|
--
|
|
-- Modified for Rockstar North by Neil Gregory
|
|
-- 07/2011
|
|
--
|
|
-- Structure containing functions and UI used by RSL_CollisionOps2 in create mode
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
-- main struct
|
|
struct RSL_CollisionOps2Attribute
|
|
(
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- Struct variables
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
INIfile = (RsConfigGetWildWestDir() + "etc/config/general/collisionOps2.ini"),
|
|
textureDirectory = (RsConfigGetWildWestDir() +"etc/config/general/collision_textures/"),
|
|
|
|
rsNorthAttFile = (RsConfigGetToolsDir() +"dcc/current/max2011/plugcfg/rsnorth.att"),
|
|
materialsDatFile = (RsConfigGetCommonDir() + "/data/materials/materials.dat"),
|
|
proceduralDatFile = (RsConfigGetCommonDir() + "/data/materials/procedural.dat"),
|
|
|
|
-- there are two surface type arrays depending on weather the object has rexbound materials or not and two arrays for each
|
|
-- because we remove "temp" surface types. The full arrays are used to get the chosen surface type, the reduced arrays
|
|
-- are used for the surface type dialogs
|
|
fullAttSurfaceTypeArray = #(),
|
|
fullMaterialsDatSurfaceTypeArray = #(),
|
|
|
|
attSurfaceTypeArray = #(),
|
|
matDatSurfaceTypeArray = #(),
|
|
|
|
-- rebound and attribute specific arrays
|
|
proceduralArray = #(),
|
|
pieceTypeArray = #(),
|
|
|
|
-- standard attribute indices
|
|
idxColType = getAttrIndex "Gta Collision" "Coll Type",
|
|
idxStairs = getAttrIndex "Gta Collision" "Stairs",
|
|
idxNoClimb = getAttrIndex "Gta Collision" "Non Climable",
|
|
idxSee = getAttrIndex "Gta Collision" "See Through",
|
|
idxNoCamera = getAttrIndex "Gta Collision" "Non Camera Collidable",
|
|
idxShoot = getAttrIndex "Gta Collision" "Shoot Through",
|
|
idxWet = getAttrIndex "Gta Collision" "Wet",
|
|
idxPath = getAttrIndex "Gta Collision" "Path",
|
|
idxPiece = getAttrIndex "Gta Collision" "Piece Type",
|
|
idxDay = getAttrIndex "Gta Collision" "Day Brightness",
|
|
idxNight = getAttrIndex "Gta Collision" "Night Brightness",
|
|
idxAudio = getAttrIndex "Gta Collision" "Audio Material",
|
|
idxRoomID = getAttrIndex "Gta Collision" "Room ID",
|
|
--idxLeeds = getAttrIndex "Gta Collision" "Edited by Leeds",
|
|
idxBVH = getAttrIndex "Gta Collision" "BVH Bound",
|
|
idxProcTint = getAttrIndex "Gta Collision" "Use Procedural Tint",
|
|
idxClothColl = getAttrIndex "Gta Collision" "Is Cloth Collision",
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- UI variables
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
toolTip = dotNetObject "ToolTip",
|
|
colourDialog = dotNetObject "ColorDialog",
|
|
|
|
copiedColour,
|
|
lastType,
|
|
lastColour,
|
|
|
|
mousePoint,
|
|
|
|
surfaceTypeForm,palletteList,surfaceTypeOkButton,surfaceTypeCancelButton,
|
|
typeControlMenu,editColour,copyColour,pasteColour,selectFaces,
|
|
|
|
pieceTypeForm,pieceTypeListview,pieceTypeOkButton,pieceTypeCancelButton,
|
|
proceduralTypeForm,proceduralTypeListview,proceduralTypeOkButton,proceduralTypeCancelButton,
|
|
miloRoomForm,miloRoomListview,miloRoomOkButton,miloRoomCancelButton,
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
--
|
|
-- FUNCTIONS
|
|
--
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- filterTemp() Removes any "temp*" surface types from the two surface type arrays
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn filterTemp =
|
|
(
|
|
local tempArray = attSurfaceTypeArray
|
|
attSurfaceTypeArray = #()
|
|
|
|
for entry in tempArray do
|
|
(
|
|
if not (matchPattern entry.type pattern:"temp*") then
|
|
(
|
|
append attSurfaceTypeArray entry
|
|
)
|
|
)
|
|
|
|
tempArray = matDatSurfaceTypeArray
|
|
matDatSurfaceTypeArray = #()
|
|
|
|
for entry in tempArray do
|
|
(
|
|
if not (matchPattern entry.type pattern:"temp*") then
|
|
(
|
|
append matDatSurfaceTypeArray entry
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- readAttFile() Reads the rsnorth.att and assigns all surface types to the att surface type arrays
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn readAttFile =
|
|
(
|
|
local dataStream = openFile rsNorthAttFile
|
|
|
|
fullAttSurfaceTypeArray = #()
|
|
attSurfaceTypeArray = #()
|
|
|
|
if dataStream != undefined then
|
|
(
|
|
skipToString dataStream "startui \"Gta Collision\" #editing \"Gta Collision\""
|
|
skipToString dataStream "list 7 \""
|
|
|
|
local line = (readDelimitedString dataStream "\"")
|
|
pieceTypeArray = filterString line ","
|
|
|
|
skipToString dataStream "tlist 367 \""
|
|
|
|
line = toUpper (readDelimitedString dataStream "\"")
|
|
attSurfaceTypeArray = filterString line ","
|
|
|
|
sort attSurfaceTypeArray
|
|
fullAttSurfaceTypeArray = deepCopy attSurfaceTypeArray
|
|
|
|
for i = 1 to attSurfaceTypeArray.count do
|
|
(
|
|
attSurfaceTypeArray[i] = (dataPair type:attSurfaceTypeArray[i] index:i)
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- readMaterialsDatFile() Reads the materials.dat and assigns all surface types to the materials dat surface type arrays
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn readMaterialsDatFile =
|
|
(
|
|
local dataStream = openFile materialsDatFile
|
|
|
|
fullMaterialsDatSurfaceTypeArray = #()
|
|
matDatSurfaceTypeArray = #()
|
|
|
|
if dataStream != undefined then
|
|
(
|
|
readLine dataStream
|
|
|
|
while not (eof dataStream) do
|
|
(
|
|
local line = readLine dataStream
|
|
|
|
if line != "" and line[1] != "#" and line[1] != "\t" then
|
|
(
|
|
local filtered = filterString line "\t"
|
|
|
|
if filtered.count > 0 then
|
|
(
|
|
append matDatSurfaceTypeArray (toUpper filtered[1])
|
|
)
|
|
)
|
|
)
|
|
|
|
sort matDatSurfaceTypeArray
|
|
fullMaterialsDatSurfaceTypeArray = deepCopy matDatSurfaceTypeArray
|
|
|
|
for i = 1 to matDatSurfaceTypeArray.count do
|
|
(
|
|
matDatSurfaceTypeArray[i] = (dataPair type:matDatSurfaceTypeArray[i] index:i)
|
|
)
|
|
|
|
-- set the last type so that we can set the surface type button
|
|
lastType = getINISetting INIFile "settings" "lastType"
|
|
|
|
if lastType == "" then lastType = matDatSurfaceTypeArray[1].type
|
|
)
|
|
else
|
|
(
|
|
print "materials dat failed to load."
|
|
)
|
|
|
|
close dataStream
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- readPoceduralDatFile() Reads the procedural.dat and assigns all procedural types to the proceduralArray
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn readPoceduralDatFile =
|
|
(
|
|
local dataStream = openFile proceduralDatFile
|
|
|
|
proceduralArray = #()
|
|
|
|
if dataStream != undefined then
|
|
(
|
|
skipToString dataStream "PROCOBJ_DATA_START"
|
|
|
|
while not (eof dataStream) do
|
|
(
|
|
local line = readLine dataStream
|
|
|
|
-- make sure we ignore the lines we don't need
|
|
if line != "" and line[1] != "#" and line[1] != "\t" and line != "PLANT_DATA_START" and line != "PLANT_DATA_END" and line != "PROCOBJ_DATA_END" then
|
|
(
|
|
local filtered = filterString line " \t"
|
|
|
|
-- make sure we ignore any lines with only tabs in them
|
|
if filtered.count > 0 then
|
|
(
|
|
appendIfUnique proceduralArray filtered[1]
|
|
)
|
|
)
|
|
)
|
|
|
|
sort proceduralArray
|
|
|
|
insertItem "NONE" proceduralArray 1
|
|
)
|
|
else
|
|
(
|
|
print "procedural dat failed to load."
|
|
)
|
|
|
|
close dataStream
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- getColours() Gets the colours set in the INI file for each surface type control in the palletteFlow
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn getColours =
|
|
(
|
|
for i = 0 to palletteFlow.controls.count - 1 do
|
|
(
|
|
local control = palletteFlow.controls.item[i]
|
|
local colour = getINISetting INIFile "surfaceColours" control.name
|
|
|
|
-- if a colour setting exists we can set the back colour for the control
|
|
if colour != "" then
|
|
(
|
|
local colourValue = readExpr (colour as stringStream)
|
|
control.backColor = RS_dotNetClass.colourClass.fromARGB colourValue.r colourValue.g colourValue.b
|
|
|
|
-- check to see if the back colour is not too similar to the fore colour
|
|
local backColTotal = colourValue.r + colourValue.g + colourValue.b
|
|
local foreColTotal = control.foreColor.r + control.foreColor.g + control.foreColor.b
|
|
|
|
-- they are too similar so we set the fore colour to either black or white
|
|
if (abs (backColTotal - foreColTotal)) < 128 then
|
|
(
|
|
if control.foreColor == RS_dotNetClass.colourClass.White then
|
|
(
|
|
control.foreColor = RS_dotNetClass.colourClass.Black
|
|
)
|
|
else
|
|
(
|
|
control.foreColor = RS_dotNetClass.colourClass.White
|
|
)
|
|
)
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- makeTexture() Creates a texture for the parsed name with the parsed colour. The texture has the parsed name printed
|
|
-- in the middle. If updateFile is true, we re-create the texture regardless of weather it exists or not.
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn makeTexture name colour updateFile:false =
|
|
(
|
|
-- attempt to make the directory if it does not already exist
|
|
makeDir textureDirectory
|
|
|
|
local file = textureDirectory + name + ".bmp"
|
|
|
|
if not (doesFileExist file) or updateFile then
|
|
(
|
|
-- delete the file if it exists
|
|
deleteFile file
|
|
|
|
-- if the colour is set to transparent, it's not be set so we make sure it's silver
|
|
if colour == RS_dotNetClass.colourClass.Transparent then
|
|
(
|
|
colour = RS_dotNetClass.colourClass.Silver
|
|
)
|
|
|
|
local bitmapImage = dotNetObject RS_dotNetClass.bitmapClass 256 256
|
|
local graphics = (dotNetClass "System.Drawing.Graphics").FromImage bitmapImage
|
|
|
|
local backBrush = dotNetObject RS_dotNetClass.solidBushClass colour
|
|
local font = dotNetObject "System.Drawing.Font" "Trebuchet MS" ((256 / 100) * 6) RS_dotNetPreset.f_Bold
|
|
local fontColour = RS_dotNetClass.brushesClass.White
|
|
|
|
-- check to see if the back colour is not too similar to the fore colour
|
|
local fontColTotal = fontColour.Color.r + fontColour.Color.g + fontColour.Color.b
|
|
local colourTotal = colour.r + colour.g + colour.b
|
|
|
|
-- they are too similar so we set the font colour to black
|
|
if (abs (fontColTotal - colourTotal)) < 128 then
|
|
(
|
|
fontColour = RS_dotNetClass.brushesClass.Black
|
|
)
|
|
|
|
local size = graphics.MeasureString name font
|
|
|
|
local x = 128.0 - (size.width * 0.5)
|
|
local y = 128.0 - (size.height * 0.5)
|
|
|
|
-- fill the bitmap with the colur and write the name string to the bitmap
|
|
graphics.FillRectangle backBrush (dotNetObject RS_dotNetClass.rectangleClass 0 0 256 256)
|
|
graphics.DrawString name font fontColour x y
|
|
|
|
bitmapImage.save file (RS_dotNetClass.imageFormatClass.bmp)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- appendSurfaceTypeData()
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
mapped fn appendSurfaceTypeData data array =
|
|
(
|
|
local found = false
|
|
|
|
for entry in array do
|
|
(
|
|
if (matchPattern entry.type pattern:data.type) then
|
|
(
|
|
found = true
|
|
)
|
|
)
|
|
|
|
if not found then
|
|
(
|
|
append array data
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- generateTextures() Generates the display textures if needed
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn generateTextures =
|
|
(
|
|
local tempArray = deepCopy attSurfaceTypeArray
|
|
appendSurfaceTypeData matDatSurfaceTypeArray tempArray
|
|
|
|
progressStart "Creating Display Textures..."
|
|
|
|
for i = 1 to tempArray.count do
|
|
(
|
|
local entry = tempArray[i]
|
|
local colour = RS_dotNetClass.colourClass.Transparent
|
|
local colourString = getINISetting INIFile "surfaceColours" entry.type
|
|
|
|
if colourString != "" then
|
|
(
|
|
local colourValue = readExpr (colourString as stringStream)
|
|
|
|
colour = RS_dotNetClass.colourClass.fromARGB colourValue.r colourValue.g colourValue.b
|
|
)
|
|
|
|
makeTexture entry.type colour
|
|
|
|
progressUpdate (i as float / tempArray.count * 100.0)
|
|
)
|
|
|
|
progressEnd()
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- showDisplayMaterial() Sets the diffuse textures in the currentMesh material to displayed
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn showDisplayMaterial =
|
|
(
|
|
local material = ::RSL_CollisionOps.currentMesh.material
|
|
|
|
case (classOf material) of
|
|
(
|
|
Standardmaterial:
|
|
(
|
|
-- un-display and then display to ensure they update
|
|
showTextureMap material material.diffuseMap false
|
|
showTextureMap material material.diffuseMap true
|
|
)
|
|
Multimaterial:
|
|
(
|
|
for subMaterial in material.materialList where (classOf subMaterial) == Standardmaterial do
|
|
(
|
|
-- un-display and then display to ensure they update
|
|
showTextureMap subMaterial subMaterial.diffuseMap false
|
|
showTextureMap subMaterial subMaterial.diffuseMap true
|
|
)
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- setColour() Sets colour for the parsed name in the INI file to the parsed colour
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn setColour name colour =
|
|
(
|
|
setINISetting INIFile "surfaceColours" name ((color colour.r colour.g colour.b) as string)
|
|
|
|
-- re-make the texture because we've changed the colour
|
|
makeTexture name colour updateFile:true
|
|
|
|
-- if we're in edit mode force the texture to be displayed so that it updates
|
|
if ::RSL_CollisionOps.currentTool.name == "editTableLayout" then
|
|
(
|
|
showDisplayMaterial()
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- addSurfaceTypeItem() Adds each parsed surfaceType to the parsed listView if it matches the parsed searchText
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
mapped fn addSurfaceTypeItem surfaceType listView searchText =
|
|
(
|
|
local okToContinue = true
|
|
|
|
-- if the searchText has some text, we check that the surfaceType matches
|
|
if searchText.count > 0 then
|
|
(
|
|
okToContinue = (matchPattern surfaceType.type pattern:("*" + searchText + "*"))
|
|
)
|
|
|
|
if okToContinue then
|
|
(
|
|
local newItem = dotNetObject "ListViewItem" surfaceType.type
|
|
newItem.selected = surfaceType.type == lastType
|
|
|
|
if newItem.selected then
|
|
(
|
|
newItem.EnsureVisible()
|
|
)
|
|
|
|
-- get the colour for the surfaceType if it exists in the INI file
|
|
local colour = getINISetting INIFile "surfaceColours" surfaceType.type
|
|
|
|
if colour != "" then
|
|
(
|
|
local colourValue = readExpr (colour as stringStream)
|
|
newItem.backColor = RS_dotNetClass.colourClass.fromARGB colourValue.r colourValue.g colourValue.b
|
|
|
|
-- check to see if the back colour is not too similar to the fore colour
|
|
local backColTotal = colourValue.r + colourValue.g + colourValue.b
|
|
local foreColTotal = newItem.foreColor.r + newItem.foreColor.g + newItem.foreColor.b
|
|
|
|
-- they are too similar so we set the fore colour to either black or white
|
|
if (abs (backColTotal - foreColTotal)) < 128 then
|
|
(
|
|
if newItem.foreColor == RS_dotNetClass.colourClass.White then
|
|
(
|
|
newItem.foreColor = RS_dotNetClass.colourClass.Black
|
|
)
|
|
else
|
|
(
|
|
newItem.foreColor = RS_dotNetClass.colourClass.White
|
|
)
|
|
)
|
|
)
|
|
|
|
listView.items.add newItem
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- addTypeItem() Adds each parsed type to the parsed listView.
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
mapped fn addTypeItem type listView =
|
|
(
|
|
local newItem = dotNetObject "ListViewItem" type
|
|
|
|
listView.items.add newItem
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- addTypeItem() Adds each parsed object to the miloRoomListview.
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
mapped fn addMiloRoomItem object =
|
|
(
|
|
-- make sure we only add GtaMloRoom class objects
|
|
if (classOf object) == GtaMloRoom then
|
|
(
|
|
local newItem = dotNetObject "ListViewItem" object.name
|
|
|
|
-- assign the object to the tag because we will use it when the user chooses the listViewItem from the dialog
|
|
newItem.tag = dotNetMXSValue object
|
|
|
|
miloRoomListview.items.add newItem
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
--
|
|
-- UI FUNCTIONS
|
|
--
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchOkButtonClick() Dispatches OkButtonClick() Called when the user presses any one of the dialog ok buttons
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchOkButtonClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.OkButtonClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- OkButtonClick() Depending on which dialog ok button was pressed, sets the relevant items up based on the choosen item
|
|
-- in the dialog
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn OkButtonClick s e =
|
|
(
|
|
case s.name of
|
|
(
|
|
"surfaceTypeOkButton":
|
|
(
|
|
case ::RSL_CollisionOps.currentTool.name of
|
|
(
|
|
"createTableLayout":
|
|
(
|
|
::RSL_CollisionOps.createUI.surfaceTypeButton.text = lastType
|
|
::RSL_CollisionOps.createUI.surfaceTypeButton.backColor = lastColour
|
|
)
|
|
"selectDisplayTableLayout":
|
|
(
|
|
::RSL_CollisionOps.selectDisplayUI.surfaceTypeButton.text = lastType
|
|
::RSL_CollisionOps.selectDisplayUI.surfaceTypeButton.backColor = lastColour
|
|
)
|
|
)
|
|
|
|
surfaceTypeForm.close()
|
|
)
|
|
"pieceTypeOkButton":
|
|
(
|
|
if pieceTypeListview.selectedItems.count == 1 then
|
|
(
|
|
case ::RSL_CollisionOps.currentTool.name of
|
|
(
|
|
"createTableLayout":
|
|
(
|
|
::RSL_CollisionOps.createUI.pieceTypeButton.text = pieceTypeListview.selectedItems.item[0].text
|
|
)
|
|
"editTableLayout":
|
|
(
|
|
::RSL_CollisionOps.editUI.pieceTypeButton.text = pieceTypeListview.selectedItems.item[0].text
|
|
)
|
|
"selectDisplayTableLayout":
|
|
(
|
|
::RSL_CollisionOps.selectDisplayUI.pieceTypeButton.text = pieceTypeListview.selectedItems.item[0].text
|
|
)
|
|
)
|
|
|
|
pieceTypeForm.close()
|
|
)
|
|
else
|
|
(
|
|
messageBox "Nothing selected. You must pick one or cancel." title:"Error..."
|
|
)
|
|
)
|
|
"proceduralTypeOkButton":
|
|
(
|
|
if proceduralTypeListview.selectedItems.count == 1 then
|
|
(
|
|
case ::RSL_CollisionOps.currentTool.name of
|
|
(
|
|
"createTableLayout":
|
|
(
|
|
::RSL_CollisionOps.createUI.proceduralTypeButton.text = proceduralTypeListview.selectedItems.item[0].text
|
|
)
|
|
"editTableLayout":
|
|
(
|
|
::RSL_CollisionOps.editUI.proceduralTypeButton.text = proceduralTypeListview.selectedItems.item[0].text
|
|
)
|
|
"selectDisplayTableLayout":
|
|
(
|
|
::RSL_CollisionOps.selectDisplayUI.proceduralTypeButton.text = proceduralTypeListview.selectedItems.item[0].text
|
|
)
|
|
)
|
|
|
|
proceduralTypeForm.close()
|
|
)
|
|
else
|
|
(
|
|
messageBox "Nothing selected. You must pick one or cancel." title:"Error..."
|
|
)
|
|
)
|
|
"miloRoomOkButton":
|
|
(
|
|
if miloRoomListview.selectedItems.count == 1 then
|
|
(
|
|
local selected = miloRoomListview.selectedItems.item[0]
|
|
local name = "None"
|
|
|
|
if selected.tag != undefined then
|
|
(
|
|
name = selected.tag.value.name
|
|
)
|
|
|
|
if ::RSL_CollisionOps.currentTool.name == "createTableLayout" then
|
|
(
|
|
::RSL_CollisionOps.createUI.miloRoomButton.text = name
|
|
::RSL_CollisionOps.createUI.miloRoomButton.tag = selected.tag
|
|
)
|
|
else
|
|
(
|
|
::RSL_CollisionOps.editUI.miloRoomButton.text = name
|
|
::RSL_CollisionOps.editUI.miloRoomButton.tag = selected.tag
|
|
)
|
|
|
|
miloRoomForm.close()
|
|
)
|
|
else
|
|
(
|
|
messageBox "Nothing selected. You must pick one or cancel." title:"Error..."
|
|
)
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchCancelButtonClick() Dispatches CancelButtonClick() Called when the user presses any one of the dialog cancel buttons
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchCancelButtonClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.CancelButtonClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- CancelButtonClick() Depending on which dialog cancel button was pressed, closes the relevant dialog
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn CancelButtonClick s e =
|
|
(
|
|
case s.name of
|
|
(
|
|
"surfaceTypeCancelButton":
|
|
(
|
|
surfaceTypeForm.close()
|
|
)
|
|
"pieceTypeCancelButton":
|
|
(
|
|
pieceTypeForm.close()
|
|
)
|
|
"proceduralTypeCancelButton":
|
|
(
|
|
proceduralTypeForm.close()
|
|
)
|
|
"miloRoomCancelButton":
|
|
(
|
|
miloRoomForm.close()
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchMiloRoomFormClosing() Dispatches miloRoomFormClosing() Called when the milo room dialog is closed
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchMiloRoomFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.miloRoomFormClosing s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- miloRoomFormClosing() Enables the main form
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn miloRoomFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.CollisionForm.enabled = true
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- miloRoomDialog() Creates the milo room dialog
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn miloRoomDialog =
|
|
(
|
|
-- dissable the main form whilst the milo room dialog is open
|
|
RSL_CollisionOps.CollisionForm.enabled = false
|
|
|
|
--In this case, we're going to use a standard form rather than the custom maxForm written for max. this is because I want to change the
|
|
-- form back colour which you can't do if you use the custom maxForm. For this to work, we need to set the parent of the form to be Max.
|
|
-- USING THIS TYPE OF FORM MEANS WE NEED TO DISSABLE ACCELERATORS WHEN WE FOCUS ON A CONTROL THAT TAKES
|
|
-- KEY PRESSES SUCH AS SPINNERS AND TEXT BOXES
|
|
|
|
--Get the max handle pointer.
|
|
local maxHandlePointer=(Windows.GetMAXHWND())
|
|
|
|
--Convert the HWND handle of Max to a dotNet system pointer
|
|
local sysPointer = DotNetObject "System.IntPtr" maxHandlePointer
|
|
|
|
--Create a dotNet wrapper containing the maxHWND
|
|
local maxHwnd = DotNetObject "MaxCustomControls.Win32HandleWrapper" sysPointer
|
|
|
|
miloRoomForm = RS_dotNetUI.Form "miloRoomForm" text:"Procedural Types" size:[216,512] min:[216,128] borderStyle:RS_dotNetPreset.FB_SizableToolWindow
|
|
miloRoomForm.StartPosition = (dotNetClass "System.Windows.Forms.FormStartPosition").CenterScreen
|
|
dotnet.addEventHandler miloRoomForm "FormClosing" dispatchMiloRoomFormClosing
|
|
|
|
miloRoomListview = RS_dotNetUI.listView "attributeListView" dockStyle:RS_dotNetPreset.DS_Fill
|
|
miloRoomListview.HeaderStyle = (dotNetClass "System.Windows.Forms.ColumnHeaderStyle").None
|
|
miloRoomListview.columns.add "Milo Rooms"
|
|
miloRoomListview.items.Add (dotNetObject "ListViewItem" "None")
|
|
|
|
miloRoomOkButton = RS_dotNetUI.Button "miloRoomOkButton" text:("OK") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler miloRoomOkButton "click" dispatchOkButtonClick
|
|
|
|
miloRoomCancelButton = RS_dotNetUI.Button "miloRoomCancelButton" text:("Cancel") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler miloRoomCancelButton "click" dispatchCancelButtonClick
|
|
|
|
miloRoomLayout = RS_dotNetUI.tableLayout "miloRoomLayout" text:"miloRoomLayout" collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Percent" value:50)) \
|
|
rows:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
|
|
|
|
miloRoomLayout.controls.add miloRoomListview 0 0
|
|
miloRoomLayout.controls.add miloRoomOkButton 0 1
|
|
miloRoomLayout.controls.add miloRoomCancelButton 1 1
|
|
|
|
miloRoomLayout.SetColumnSpan miloRoomListview 2
|
|
|
|
miloRoomForm.controls.add miloRoomLayout
|
|
|
|
addMiloRoomItem helpers
|
|
miloRoomListview.AutoResizeColumns (dotNetClass "ColumnHeaderAutoResizeStyle").HeaderSize
|
|
|
|
miloRoomForm.show maxHwnd
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchProceduralFormClosing() Dispatches proceduralFormClosing() Called when the procedural dialog is closed
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchProceduralFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.proceduralFormClosing s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- proceduralFormClosing() Enables the main form
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn proceduralFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.CollisionForm.enabled = true
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- proceduralFormClosing() Creates the procedural dialog
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn proceduralTypeDialog =
|
|
(
|
|
-- dissable the main form whilst the procedural dialog is open
|
|
RSL_CollisionOps.CollisionForm.enabled = false
|
|
|
|
--In this case, we're going to use a standard form rather than the custom maxForm written for max. this is because I want to change the
|
|
-- form back colour which you can't do if you use the custom maxForm. For this to work, we need to set the parent of the form to be Max.
|
|
-- USING THIS TYPE OF FORM MEANS WE NEED TO DISSABLE ACCELERATORS WHEN WE FOCUS ON A CONTROL THAT TAKES
|
|
-- KEY PRESSES SUCH AS SPINNERS AND TEXT BOXES
|
|
|
|
--Get the max handle pointer.
|
|
local maxHandlePointer=(Windows.GetMAXHWND())
|
|
|
|
--Convert the HWND handle of Max to a dotNet system pointer
|
|
local sysPointer = DotNetObject "System.IntPtr" maxHandlePointer
|
|
|
|
--Create a dotNet wrapper containing the maxHWND
|
|
local maxHwnd = DotNetObject "MaxCustomControls.Win32HandleWrapper" sysPointer
|
|
|
|
proceduralTypeForm = RS_dotNetUI.Form "proceduralTypeForm" text:"Procedural Types" size:[216,512] min:[216,128] borderStyle:RS_dotNetPreset.FB_SizableToolWindow
|
|
proceduralTypeForm.StartPosition = (dotNetClass "System.Windows.Forms.FormStartPosition").CenterScreen
|
|
dotnet.addEventHandler proceduralTypeForm "FormClosing" dispatchProceduralFormClosing
|
|
|
|
proceduralTypeListview = RS_dotNetUI.listView "attributeListView" dockStyle:RS_dotNetPreset.DS_Fill
|
|
proceduralTypeListview.HeaderStyle = (dotNetClass "System.Windows.Forms.ColumnHeaderStyle").None
|
|
proceduralTypeListview.columns.add "type"
|
|
|
|
proceduralTypeOkButton = RS_dotNetUI.Button "proceduralTypeOkButton" text:("OK") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler proceduralTypeOkButton "click" dispatchOkButtonClick
|
|
|
|
proceduralTypeCancelButton = RS_dotNetUI.Button "proceduralTypeCancelButton" text:("Cancel") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler proceduralTypeCancelButton "click" dispatchCancelButtonClick
|
|
|
|
proceduralTypeLayout = RS_dotNetUI.tableLayout "proceduralTypeLayout" text:"proceduralTypeLayout" collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Percent" value:50)) \
|
|
rows:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
|
|
|
|
proceduralTypeLayout.controls.add proceduralTypeListview 0 0
|
|
proceduralTypeLayout.controls.add proceduralTypeOkButton 0 1
|
|
proceduralTypeLayout.controls.add proceduralTypeCancelButton 1 1
|
|
|
|
proceduralTypeLayout.SetColumnSpan proceduralTypeListview 2
|
|
|
|
proceduralTypeForm.controls.add proceduralTypeLayout
|
|
|
|
addTypeItem proceduralArray proceduralTypeListview
|
|
proceduralTypeListview.AutoResizeColumns (dotNetClass "ColumnHeaderAutoResizeStyle").HeaderSize
|
|
|
|
proceduralTypeForm.show maxHwnd
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchPieceFormClosing() Dispatches pieceFormClosing() Called when the piece type dialog is closed
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchPieceFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.pieceFormClosing s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- pieceFormClosing() Enables the main form
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn pieceFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.CollisionForm.enabled = true
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- pieceFormClosing() Creates the piece type dialog
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn pieceTypeDialog =
|
|
(
|
|
-- dissable the main form whilst the piece type dialog is open
|
|
RSL_CollisionOps.CollisionForm.enabled = false
|
|
|
|
--In this case, we're going to use a standard form rather than the custom maxForm written for max. this is because I want to change the
|
|
-- form back colour which you can't do if you use the custom maxForm. For this to work, we need to set the parent of the form to be Max.
|
|
-- USING THIS TYPE OF FORM MEANS WE NEED TO DISSABLE ACCELERATORS WHEN WE FOCUS ON A CONTROL THAT TAKES
|
|
-- KEY PRESSES SUCH AS SPINNERS AND TEXT BOXES
|
|
|
|
--Get the max handle pointer.
|
|
local maxHandlePointer=(Windows.GetMAXHWND())
|
|
|
|
--Convert the HWND handle of Max to a dotNet system pointer
|
|
local sysPointer = DotNetObject "System.IntPtr" maxHandlePointer
|
|
|
|
--Create a dotNet wrapper containing the maxHWND
|
|
local maxHwnd = DotNetObject "MaxCustomControls.Win32HandleWrapper" sysPointer
|
|
|
|
pieceTypeForm = RS_dotNetUI.Form "pieceTypeForm" text:"Piece Types" size:[216,512] min:[216,128] borderStyle:RS_dotNetPreset.FB_SizableToolWindow
|
|
pieceTypeForm.StartPosition = (dotNetClass "System.Windows.Forms.FormStartPosition").CenterScreen
|
|
dotnet.addEventHandler pieceTypeForm "FormClosing" dispatchPieceFormClosing
|
|
|
|
pieceTypeListview = RS_dotNetUI.listView "attributeListView" dockStyle:RS_dotNetPreset.DS_Fill
|
|
pieceTypeListview.HeaderStyle = (dotNetClass "System.Windows.Forms.ColumnHeaderStyle").None
|
|
pieceTypeListview.columns.add "type"
|
|
|
|
pieceTypeOkButton = RS_dotNetUI.Button "pieceTypeOkButton" text:("OK") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler pieceTypeOkButton "click" dispatchOkButtonClick
|
|
|
|
pieceTypeCancelButton = RS_dotNetUI.Button "pieceTypeCancelButton" text:("Cancel") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler pieceTypeCancelButton "click" dispatchCancelButtonClick
|
|
|
|
pieceTypeLayout = RS_dotNetUI.tableLayout "pieceTypeLayout" text:"pieceTypeLayout" collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Percent" value:50)) \
|
|
rows:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
|
|
|
|
pieceTypeLayout.controls.add pieceTypeListview 0 0
|
|
pieceTypeLayout.controls.add pieceTypeOkButton 0 1
|
|
pieceTypeLayout.controls.add pieceTypeCancelButton 1 1
|
|
|
|
pieceTypeLayout.SetColumnSpan pieceTypeListview 2
|
|
|
|
pieceTypeForm.controls.add pieceTypeLayout
|
|
|
|
addTypeItem pieceTypeArray pieceTypeListview
|
|
pieceTypeListview.AutoResizeColumns (dotNetClass "ColumnHeaderAutoResizeStyle").HeaderSize
|
|
|
|
pieceTypeForm.show maxHwnd
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchSurfaceFormClosing() Dispatches surfaceFormClosing() Called when the surface type dialog is closed
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchSurfaceFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.surfaceFormClosing s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- surfaceFormClosing() Enables the main form
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn surfaceFormClosing s e =
|
|
(
|
|
::RSL_CollisionOps.CollisionForm.enabled = true
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchEditColourClick() Dispatches editColourClick() Called when the editColour menu item is clicked
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchEditColourClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.editColourClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- editColourClick() Displays the colour dialog and sets the new colour
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn editColourClick s e =
|
|
(
|
|
-- get the listView the menu item is assigned to
|
|
local listView = s.Owner.SourceControl
|
|
-- get the list view item that was right clicked
|
|
local source = listView.GetItemAt mousePoint.x mousePoint.y
|
|
|
|
if source != undefined then
|
|
(
|
|
-- set the colour dialog colour to the back colour of the right clicked list view item
|
|
colourDialog.Color = source.backColor
|
|
|
|
-- if the user presses the ok button in the colour dialog, we can set the colour
|
|
if (colourDialog.ShowDialog()) == (dotNetClass "DialogResult").ok then
|
|
(
|
|
source.backColor = colourDialog.Color
|
|
|
|
-- check to see if the fore colour and back colour are too similar
|
|
local backColTotal = source.backColor.r + source.backColor.g + source.backColor.b
|
|
local foreColTotal = source.foreColor.r + source.foreColor.g + source.foreColor.b
|
|
|
|
-- they are so we set the fore colour to either white or black
|
|
if (abs (backColTotal - foreColTotal)) < 128 then
|
|
(
|
|
if source.foreColor == RS_dotNetClass.colourClass.White then
|
|
(
|
|
source.foreColor = RS_dotNetClass.colourClass.Black
|
|
)
|
|
else
|
|
(
|
|
source.foreColor = RS_dotNetClass.colourClass.White
|
|
)
|
|
)
|
|
|
|
-- save the colour to the INI file and update the texture
|
|
setColour source.text source.backColor
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchCopyPasteColourClick() Dispatches copyPasteColourClick() Called when either the copyColour or pasteColour menu
|
|
-- items are clicked
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchCopyPasteColourClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.copyPasteColourClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- copyPasteColourClick() Depending on which menu item was clicked, copies the right clicked list view item's colour or pastes
|
|
-- an alread copied colour onto the right clicked list view item
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn copyPasteColourClick s e =
|
|
(
|
|
-- get the listView the menu item is assigned to
|
|
local listView = s.Owner.SourceControl
|
|
-- get the list view item that was right clicked
|
|
local source = listView.GetItemAt mousePoint.x mousePoint.y
|
|
|
|
if source != undefined then
|
|
(
|
|
case s.name of
|
|
(
|
|
"copyColour":
|
|
(
|
|
-- set the copiedColour struct variable to the back colour of the right clicked list view item
|
|
-- and enable the pasteColour menu item
|
|
copiedColour = source.backColor
|
|
|
|
pasteColour.enabled = true
|
|
)
|
|
"pasteColour":
|
|
(
|
|
if copiedColour != undefined then
|
|
(
|
|
-- set the bacl colour of the right clicked list view item to the copiedColour
|
|
source.backColor = copiedColour
|
|
|
|
-- check to see if the fore colour and back colour are too similar
|
|
local backColTotal = copiedColour.r + copiedColour.g + copiedColour.b
|
|
local foreColTotal = source.foreColor.r + source.foreColor.g + source.foreColor.b
|
|
|
|
-- they are so we set the fore colour to either white or black
|
|
if (abs (backColTotal - foreColTotal)) < 128 then
|
|
(
|
|
if source.foreColor == RS_dotNetClass.colourClass.White then
|
|
(
|
|
source.foreColor = RS_dotNetClass.colourClass.Black
|
|
)
|
|
else
|
|
(
|
|
source.foreColor = RS_dotNetClass.colourClass.White
|
|
)
|
|
)
|
|
|
|
-- save the colour to the INI file and update the texture
|
|
setColour source.text source.backColor
|
|
)
|
|
)
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchSelectFacesClick() Dispatches selectFacesClick() Called when the selectFaces copyColour menu item is clicked
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchSelectFacesClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.selectFacesClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- selectFacesClick() Selects any faces in the currentMesh if they are set to the surface type of the right clicked list
|
|
-- view item. THIS IS ONLY AVAILABLE IN EDIT MODE
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn selectFacesClick s e =
|
|
(
|
|
-- get the list view
|
|
local listView = s.Tag.Value
|
|
-- get the right clicked list view item
|
|
local source = listView.GetItemAt mousePoint.x mousePoint.y
|
|
-- get all the surface values for the currentMesh. Uses SimpleFaceData
|
|
local surfaceArray = ::RSL_CollisionOps.editUI.surfaceChannel.getValues()
|
|
local faceArray = #()
|
|
|
|
if ::RSL_CollisionOps.currentTool.name == "editTableLayout" then
|
|
(
|
|
-- check to see if the control key is being held down. If so, we add the currently selected faces to faceArray
|
|
-- so that we will grow the selection rather than replace it
|
|
local control = dotNetClass "system.windows.forms.control"
|
|
|
|
if control.modifierKeys == control.modifierKeys.Control then
|
|
(
|
|
faceArray = for f in ::RSL_CollisionOps.currentMesh.selectedFaces collect f.index
|
|
)
|
|
)
|
|
|
|
-- loop through all the surface types on the object and append any face indices for face that have the surface type
|
|
for i = 1 to surfaceArray.count do
|
|
(
|
|
local surfaceType = fullMaterialsDatSurfaceTypeArray[surfaceArray[i]]
|
|
|
|
if surfaceType == source.text then
|
|
(
|
|
appendIfUnique faceArray i
|
|
)
|
|
)
|
|
|
|
-- make sure we're in modify mode and face mode, then select the faces
|
|
setCommandPanelTaskMode #modify
|
|
subObjectLevel = 4
|
|
|
|
::RSL_CollisionOps.currentMesh.selectedFaces = #()
|
|
::RSL_CollisionOps.currentMesh.selectedFaces = faceArray
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchRightClickOpening() Dispatches rightClickOpening() Called when the user right clicks a list view item in the surface
|
|
-- type pallette
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchRightClickOpening s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.rightClickOpening s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- rightClickOpening() Sets the mousePoint struct variable to the mouse position and the enabled state of the selectFaces
|
|
-- menu item
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn rightClickOpening s e =
|
|
(
|
|
local listView = s.SourceControl
|
|
mousePoint = listView.PointToClient (listView.Cursor.Position)
|
|
|
|
selectFaces.enabled = ::RSL_CollisionOps.currentType == #rexbound
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchPalletteListClick() Dispatches PalletteListClick() Called when the user clicks a list view item in the surface
|
|
-- type pallette
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchPalletteListClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.PalletteListClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- PalletteListClick() Sets the mousePoint struct variable to the mouse position, the lastType stuct variable to the text
|
|
-- of the selected list view item and the lastColour struct variable to the back colour of the selected list view item
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn PalletteListClick s e =
|
|
(
|
|
mousePoint = s.PointToClient (s.Cursor.Position)
|
|
|
|
if s.selectedItems.count == 1 then
|
|
(
|
|
lastType = s.selectedItems.item[0].text
|
|
lastColour = s.selectedItems.item[0].backColor
|
|
|
|
setINISetting INIFile "settings" "lastType" lastType
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchPalletteListDoubleClick() Dispatches palletteListDoubleClick() Called when the user double clicks a list view item
|
|
-- in the surface type pallette
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchPalletteListDoubleClick s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.palletteListDoubleClick s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- palletteListDoubleClick() If we're in Create mode, sets the lastType stuct variable to the text of the selected list view
|
|
-- item and the lastColour struct variable to the back colour of the selected list view item and then closes the surface type dialog.
|
|
-- If we're in Edit mode, runs the selectFacesClick function.
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn palletteListDoubleClick s e =
|
|
(
|
|
if s.selectedItems.count == 1 then
|
|
(
|
|
if ::RSL_CollisionOps.currentTool.name == "editTableLayout" and ::RSL_CollisionOps.currentType == #rebound then
|
|
(
|
|
selectFacesClick selectFaces ""
|
|
)
|
|
else
|
|
(
|
|
lastType = s.selectedItems.item[0].text
|
|
lastColour = s.selectedItems.item[0].backColor
|
|
|
|
setINISetting INIFile "settings" "lastType" lastType
|
|
|
|
OkButtonClick surfaceTypeOkButton ""
|
|
)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- dispatchPalletteListResize() Dispatches palletteListResize() Called when the user resizes the surface type dialog or pallette
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn dispatchPalletteListResize s e =
|
|
(
|
|
::RSL_CollisionOps.attribute.palletteListResize s e
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- palletteListResize() Resizes the list view column
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn palletteListResize s e =
|
|
(
|
|
if palletteList.columns.count > 0 then
|
|
(
|
|
palletteList.columns.Item[0].width = (::RSL_CollisionOps.CollisionForm.width - 42)
|
|
)
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- surfaceTypePallette() Creates the surface type pallette for the Edit mode. The parsed type variable controls which
|
|
-- surface type array we use to populate the pallette. The parsed searchText variable is used the filter the surface types.
|
|
-- Returns the list view.
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn surfaceTypePallette type searchText =
|
|
(
|
|
editColour = RS_dotNetUI.ToolStripMenuItem "editColour" text:"Edit Colour"
|
|
dotnet.addEventHandler editColour "Click" dispatchEditColourClick
|
|
|
|
copyColour = RS_dotNetUI.ToolStripMenuItem "copyColour" text:"Copy Colour"
|
|
dotnet.addEventHandler copyColour "Click" dispatchCopyPasteColourClick
|
|
|
|
pasteColour = RS_dotNetUI.ToolStripMenuItem "pasteColour" text:"Paste Colour"
|
|
pasteColour.enabled = false
|
|
dotnet.addEventHandler pasteColour "Click" dispatchCopyPasteColourClick
|
|
|
|
selectFaces = RS_dotNetUI.ToolStripMenuItem "selectFaces" text:"Select Faces"
|
|
selectFaces.enabled = (type == #rexBound)
|
|
dotnet.addEventHandler selectFaces "Click" dispatchSelectFacesClick
|
|
|
|
typeControlMenu = RS_dotNetUI.ContextMenuStrip "typeControlMenu" items:#(selectFaces,RS_dotNetUI.separator(),editColour,RS_dotNetUI.separator(),copyColour,pasteColour)
|
|
dotnet.addEventHandler typeControlMenu "Opening" dispatchRightClickOpening
|
|
|
|
colourDialog.FullOpen = true
|
|
|
|
palletteList = RS_dotNetUI.listView "palletteList" dockStyle:RS_dotNetPreset.DS_Fill
|
|
palletteList.view = (dotNetClass "System.Windows.Forms.View").Details
|
|
palletteList.HeaderStyle = (dotNetClass "System.Windows.Forms.ColumnHeaderStyle").None
|
|
palletteList.Sorting = (dotNetClass "System.Windows.Forms.SortOrder").None
|
|
palletteList.HideSelection = false
|
|
palletteList.scrollable = true
|
|
palletteList.fullRowSelect = true
|
|
palletteList.ContextMenuStrip = typeControlMenu
|
|
palletteList.backColor = RS_dotNetPreset.controlColour_Medium
|
|
dotnet.addEventHandler palletteList "SelectedIndexChanged" dispatchPalletteListClick
|
|
dotnet.addEventHandler palletteList "MouseDoubleClick" dispatchPalletteListDoubleClick
|
|
dotNet.addEventHandler palletteList "Resize" dispatchPalletteListResize
|
|
|
|
-- Depending on the parsed type, we populate the pallette from the correct surface type array
|
|
if type == #primitive then
|
|
(
|
|
addSurfaceTypeItem attSurfaceTypeArray palletteList searchText
|
|
)
|
|
else
|
|
(
|
|
addSurfaceTypeItem matDatSurfaceTypeArray palletteList searchText
|
|
)
|
|
|
|
selectFaces.tag = dotNetMXSValue palletteList
|
|
palletteList.Columns.Add "SurfaceType" (::RSL_CollisionOps.CollisionForm.width - 42)
|
|
|
|
palletteList
|
|
),
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
-- surfaceTypeDialog() Creates the surface type dialog use in Create mode. The parsed type variable controls which
|
|
-- surface type array we use to populate the pallette.
|
|
---------------------------------------------------------------------------------------------------------------------------------------
|
|
fn surfaceTypeDialog type =
|
|
(
|
|
RSL_CollisionOps.CollisionForm.enabled = false
|
|
|
|
--In this case, we're going to use a standard form rather than the custom maxForm written for max. this is because I want to change the
|
|
-- form back colour which you can't do if you use the custom maxForm. For this to work, we need to set the parent of the form to be Max.
|
|
-- USING THIS TYPE OF FORM MEANS WE NEED TO DISSABLE ACCELERATORS WHEN WE FOCUS ON A CONTROL THAT TAKES
|
|
-- KEY PRESSES SUCH AS SPINNERS AND TEXT BOXES
|
|
|
|
--Get the max handle pointer.
|
|
local maxHandlePointer=(Windows.GetMAXHWND())
|
|
|
|
--Convert the HWND handle of Max to a dotNet system pointer
|
|
local sysPointer = DotNetObject "System.IntPtr" maxHandlePointer
|
|
|
|
--Create a dotNet wrapper containing the maxHWND
|
|
local maxHwnd = DotNetObject "MaxCustomControls.Win32HandleWrapper" sysPointer
|
|
|
|
surfaceTypeForm = RS_dotNetUI.Form "surfaceTypeForm" text:"Surface Types" size:[216,512] min:[216,128] borderStyle:RS_dotNetPreset.FB_SizableToolWindow
|
|
surfaceTypeForm.StartPosition = (dotNetClass "System.Windows.Forms.FormStartPosition").CenterScreen
|
|
dotnet.addEventHandler surfaceTypeForm "FormClosing" dispatchSurfaceFormClosing
|
|
|
|
editColour = RS_dotNetUI.ToolStripMenuItem "editColour" text:"Edit Colour"
|
|
dotnet.addEventHandler editColour "Click" dispatchEditColourClick
|
|
|
|
copyColour = RS_dotNetUI.ToolStripMenuItem "copyColour" text:"Copy Colour"
|
|
dotnet.addEventHandler copyColour "Click" dispatchCopyPasteColourClick
|
|
|
|
pasteColour = RS_dotNetUI.ToolStripMenuItem "pasteColour" text:"Paste Colour"
|
|
pasteColour.enabled = false
|
|
dotnet.addEventHandler pasteColour "Click" dispatchCopyPasteColourClick
|
|
|
|
typeControlMenu = RS_dotNetUI.ContextMenuStrip "typeControlMenu" items:#(editColour,RS_dotNetUI.separator(),copyColour,pasteColour)
|
|
|
|
colourDialog.FullOpen = true
|
|
|
|
palletteList = RS_dotNetUI.listView "palletteList" dockStyle:RS_dotNetPreset.DS_Fill
|
|
palletteList.view = (dotNetClass "System.Windows.Forms.View").Details
|
|
palletteList.HeaderStyle = (dotNetClass "System.Windows.Forms.ColumnHeaderStyle").None
|
|
palletteList.Sorting = (dotNetClass "System.Windows.Forms.SortOrder").None
|
|
palletteList.HideSelection = false
|
|
palletteList.scrollable = true
|
|
palletteList.fullRowSelect = true
|
|
palletteList.ContextMenuStrip = typeControlMenu
|
|
palletteList.backColor = RS_dotNetPreset.controlColour_Medium
|
|
dotnet.addEventHandler palletteList "SelectedIndexChanged" dispatchPalletteListClick
|
|
dotnet.addEventHandler palletteList "MouseDoubleClick" dispatchPalletteListDoubleClick
|
|
dotNet.addEventHandler palletteList "Resize" dispatchPalletteListResize
|
|
|
|
-- Depending on the parsed type, we populate the pallette from the correct surface type array
|
|
if type == #primitive then
|
|
(
|
|
addSurfaceTypeItem attSurfaceTypeArray palletteList ""
|
|
)
|
|
else
|
|
(
|
|
addSurfaceTypeItem matDatSurfaceTypeArray palletteList ""
|
|
)
|
|
|
|
palletteList.Columns.Add "SurfaceType" (::RSL_CollisionOps.CollisionForm.width - 42)
|
|
|
|
surfaceTypeOkButton = RS_dotNetUI.Button "surfaceTypeOkButton" text:("OK") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler surfaceTypeOkButton "click" dispatchOkButtonClick
|
|
|
|
surfaceTypeCancelButton = RS_dotNetUI.Button "surfaceTypeCancelButton" text:("Cancel") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 2)
|
|
dotnet.addEventHandler surfaceTypeCancelButton "click" dispatchCancelButtonClick
|
|
|
|
surfaceTypeLayout = RS_dotNetUI.tableLayout "surfaceTypeLayout" text:"surfaceTypeLayout" collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Percent" value:50)) \
|
|
rows:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
|
|
|
|
surfaceTypeLayout.controls.add palletteList 0 0
|
|
surfaceTypeLayout.controls.add surfaceTypeOkButton 0 1
|
|
surfaceTypeLayout.controls.add surfaceTypeCancelButton 1 1
|
|
|
|
surfaceTypeLayout.SetColumnSpan palletteList 2
|
|
|
|
surfaceTypeForm.controls.add surfaceTypeLayout
|
|
|
|
surfaceTypeForm.show maxHwnd
|
|
)
|
|
) |