Inheritance diagram for BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode:

Public Types
enum	IndirectMethod

Public Member Functions
	MDL0MaterialNode ()

void	UpdateAsMetal ()

bool	CheckIfMetal ()

override bool	OnInitialize ()

override void	OnPopulate ()

override int	OnCalculateSize (bool force)

override void	OnRebuild (VoidPtr address, int length, bool force)

override void	Export (string outPath)

override void	SignalPropertyChange ()

void	UseProgram (MDL0ObjectNode node, bool forceRemake=false)

void	ApplyViewportLighting (ModelPanelViewport viewport)

void	GenerateShadowMaterial ()

void	GenerateSpyMaterial ()

override void	Replace (string fileName)

override void	Remove ()

void	Remove (bool removeAttached)

Bitmap	GetImage (int index)

override void	SignalPropertyChange ()

Public Member Functions inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
void	OnRenamed ()

List< ResourceNode >	GetChildrenRecursive ()
	Used primarily to get bone lists. Kept for all resource nodes for utility. More...

virtual void	SignalPropertyChange ()

virtual void	Dispose ()

void	SelectChildAtIndex (int index)

void	UpdateProperties ()

void	UpdateCurrentControl ()

virtual bool	MoveUp ()

virtual bool	MoveDown ()

virtual void	OnMoved ()

virtual void	DoMoveDown ()

virtual void	DoMoveDown (bool select)

virtual void	DoMoveUp ()

virtual void	DoMoveUp (bool select)

virtual bool	AddUp ()

virtual bool	AddDown ()

virtual bool	ToParent ()

void	Populate (int levels=-1)

virtual void	OnPopulate ()

void	Initialize (ResourceNode parent, FileMap source)

void	Initialize (ResourceNode parent, VoidPtr address, int length)

void	Initialize (ResourceNode parent, DataSource origSource)

virtual void	Initialize (ResourceNode parent, DataSource origSource, DataSource uncompSource)

virtual bool	OnInitialize ()

virtual void	Restore ()

virtual void	Remove ()

virtual void	RemoveChild (ResourceNode child)

virtual void	AddChild (ResourceNode child)

virtual void	AddChild (ResourceNode child, bool change)

virtual void	InsertChild (ResourceNode child, int index)

virtual void	InsertChild (ResourceNode child, bool change, int index)

void	SetSizeInternal (int size)

virtual void	Replace (string fileName)

virtual void	Replace (ResourceNode node)

virtual void	Replace (string fileName, FileMapProtect prot, FileOptions options)

virtual void	ReplaceRaw (VoidPtr address, int length)

virtual void	ReplaceRaw (FileMap map)

virtual void	Export (string outPath)

void	Export (FileStream outStream)

virtual void	ExportUncompressed (string outPath)

void	ExportUncompressed (FileStream outStream)

virtual void	Rebuild ()

virtual void	Rebuild (bool force)

virtual void	Rebuild (VoidPtr address, int length, bool force)

virtual void	OnRebuild (VoidPtr address, int length, bool force)

virtual int	CalculateSize (bool force)

virtual int	OnCalculateSize (bool force)

void	Merge ()

void	Merge (bool forceBuild)

ResourceNode	FindChildByType (string path, bool searchChildren, params ResourceType[] types)

ResourceNode	FindChildByType (string path, bool searchChildren, StringComparison compare, params ResourceType[] types)

ResourceNode	FindChild (string path)

ResourceNode	FindChild (string path, bool searchChildren)

ResourceNode	FindChild (string path, StringComparison compare)

ResourceNode	FindChild (string path, bool searchChildren, StringComparison compare)

ResourceNode[]	FindChildrenByClassType (string path, Type type)

ResourceNode[]	FindChildrenByType (string path, ResourceType type)

ResourceNode[]	FindChildrenByTypeInGroup (string path, ResourceType type, byte group)

ResourceNode[]	FindChildrenByName (string name)

unsafe string	FindName (string name)

ResourceNode	FindEmbeddedIndex (int index)

virtual unsafe byte[]	MD5 ()
	Find the MD5 checksum of this node's data. If this node doesn't have any data (BRESGroupNode, for example), this method will return null. More...

string	MD5Str ()
	Get the result of the MD5() function as a string of hexadecimal digits. If MD5() returns null, this method will return an empty string. More...

ResourceNode	PrevSibling ()

ResourceNode	NextSibling ()

override string	ToString ()

virtual void	SortChildren ()

Bitmap	GetImage (int index)

Public Attributes
bool	_updating

byte	_indirectMethod1

byte	_indirectMethod2

byte	_indirectMethod3

byte	_indirectMethod4

byte	_activeStages

byte	_activeIndStages

byte	_depthTestBeforeTexture

sbyte	_normMapRefLight1 = -1

sbyte	_normMapRefLight2 = -1

sbyte	_normMapRefLight3 = -1

sbyte	_normMapRefLight4 = -1

sbyte	_lightSetIndex = 20

sbyte	_fogIndex = 4

CullMode	_cull = CullMode.Cull_Inside

uint	_texMtxFlags

LightChannel	_chan1

LightChannel	_chan2

List< MDL0ObjectNode >	_objects = new List<MDL0ObjectNode>()

List< XFData >	XFCmds = new List<XFData>()

GXAlphaFunction	_alphaFunc = GXAlphaFunction.Default

ZMode	_zMode = ZMode.Default

BlendMode	_blendMode = BlendMode.Default

ConstantAlpha	_constantAlpha = ConstantAlpha.Default

MatTevColorBlock	_tevColorBlock = MatTevColorBlock.Default

MatTevKonstBlock	_tevKonstBlock = MatTevKonstBlock.Default

MatIndMtxBlock	_indMtx = MatIndMtxBlock.Default

string	_vertexShaderSource

int	_vertexShaderHandle

string	_fragShaderSource

int	_fragShaderHandle

int	_programHandle

bool	_internalForceRemake

TextureFrameState[]	_indirectFrameStates = new TextureFrameState[3]

Vector4	amb1

Vector4	amb2

Vector4	clr1

Vector4	clr2

Vector4	k1

Vector4	k2

Vector4	k3

Vector4	k4

Vector4	c1

Vector4	c2

Vector4	c3

bool	_scn0Applied

Vector4	_ambientLight

FogAnimationFrame	_fog

GLSLLightFrame[]	_lights = new GLSLLightFrame[8]

Public Attributes inherited from BrawlLib.SSBB.ResourceNodes.MDL0EntryNode
int	_entryIndex

Public Attributes inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
Form	_mainForm

string	_name

string	_origPath

ResourceNode	_parent

List< ResourceNode >	_children = new List<ResourceNode>()

int	_calcSize

EventHandler	UpdateControl

MoveEventHandler	MovedDown

ResourceEventHandler	Renamed

ResourceEventHandler	PropertyChanged

ResourceEventHandler	Replaced

ResourceEventHandler	Restored

ResourceChildEventHandler	ChildRemoved

bool	_isPopulating

bool	_replaced

Properties
override ResourceType	ResourceFileType `[get]`

override bool	AllowDuplicateNames `[get]`

UserDataCollection	UserEntries `[get, set]`

MDL0ObjectNode[]	Objects `[get]`

GXColorS10	ConstantColor0 `[get, set]`

GXColorS10	ConstantColor1 `[get, set]`

GXColorS10	ConstantColor2 `[get, set]`

GXColorS10	ConstantColor3 `[get, set]`

GXColorS10	Color0 `[get, set]`

GXColorS10	Color1 `[get, set]`

GXColorS10	Color2 `[get, set]`

MDL0ShaderNode	ShaderNode `[get, set]`

string	Shader `[get, set]`

byte	Ref0 `[get, set]`

AlphaCompare	Comp0 `[get, set]`

AlphaOp	Logic `[get, set]`

byte	Ref1 `[get, set]`

AlphaCompare	Comp1 `[get, set]`

bool	CompareBeforeTexture `[get, set]`

bool	EnableDepthTest `[get, set]`

bool	EnableDepthUpdate `[get, set]`

GXCompare	DepthFunction `[get, set]`

bool	EnableBlend `[get, set]`

bool	EnableBlendLogic `[get, set]`

BlendFactor	SrcFactor `[get, set]`

GXLogicOp	BlendLogicOp `[get, set]`

BlendFactor	DstFactor `[get, set]`

bool	Subtract `[get, set]`

bool	ConstantAlphaEnabled `[get, set]`

byte	ConstantAlphaValue `[get, set]`

IndirectMethod	IndirectMethodTex1 `[get, set]`

IndirectMethod	IndirectMethodTex2 `[get, set]`

IndirectMethod	IndirectMethodTex3 `[get, set]`

IndirectMethod	IndirectMethodTex4 `[get, set]`

IndTexScale	IndirectTex1ScaleS `[get, set]`

IndTexScale	IndirectTex1ScaleT `[get, set]`

IndTexScale	IndirectTex2ScaleS `[get, set]`

IndTexScale	IndirectTex2ScaleT `[get, set]`

IndTexScale	IndirectTex3ScaleS `[get, set]`

IndTexScale	IndirectTex3ScaleT `[get, set]`

IndTexScale	IndirectTex4ScaleS `[get, set]`

IndTexScale	IndirectTex4ScaleT `[get, set]`

LightChannel	LightChannel0 `[get]`

LightChannel	LightChannel1 `[get]`

LightingChannelFlags	C1Flags `[get, set]`

RGBAPixel	C1MaterialColor `[get, set]`

RGBAPixel	C1AmbientColor `[get, set]`

GXColorSrc	C1ColorMaterialSource `[get, set]`

bool	C1ColorEnabled `[get, set]`

GXColorSrc	C1ColorAmbientSource `[get, set]`

GXDiffuseFn	C1ColorDiffuseFunction `[get, set]`

GXAttnFn	C1ColorAttenuation `[get, set]`

MatChanLights	C1ColorLights `[get, set]`

GXColorSrc	C1AlphaMaterialSource `[get, set]`

bool	C1AlphaEnabled `[get, set]`

GXColorSrc	C1AlphaAmbientSource `[get, set]`

GXDiffuseFn	C1AlphaDiffuseFunction `[get, set]`

GXAttnFn	C1AlphaAttenuation `[get, set]`

MatChanLights	C1AlphaLights `[get, set]`

LightingChannelFlags	C2Flags `[get, set]`

RGBAPixel	C2MaterialColor `[get, set]`

RGBAPixel	C2AmbientColor `[get, set]`

GXColorSrc	C2ColorMaterialSource `[get, set]`

bool	C2ColorEnabled `[get, set]`

GXColorSrc	C2ColorAmbientSource `[get, set]`

GXDiffuseFn	C2ColorDiffuseFunction `[get, set]`

GXAttnFn	C2ColorAttenuation `[get, set]`

MatChanLights	C2ColorLights `[get, set]`

GXColorSrc	C2AlphaMaterialSource `[get, set]`

bool	C2AlphaEnabled `[get, set]`

GXColorSrc	C2AlphaAmbientSource `[get, set]`

GXDiffuseFn	C2AlphaDiffuseFunction `[get, set]`

GXAttnFn	C2AlphaAttenuation `[get, set]`

MatChanLights	C2AlphaLights `[get, set]`

TexMatrixMode	TextureMatrixMode `[get, set]`

bool	XLUMaterial `[get, set]`

int	ID `[get]`

int	ActiveShaderStages `[get, set]`

int	IndirectShaderStages `[get, set]`

CullMode	CullMode `[get, set]`

sbyte	LightSetIndex `[get, set]`

sbyte	FogIndex `[get, set]`

sbyte	NormMapRefLight1 `[get, set]`

sbyte	NormMapRefLight2 `[get, set]`

sbyte	NormMapRefLight3 `[get, set]`

sbyte	NormMapRefLight4 `[get, set]`

bool	IsMetal `[get]`

MDL0MaterialNode	MetalMaterial `[get]`

int	ImageCount `[get]`

Properties inherited from BrawlLib.SSBB.ResourceNodes.MDL0EntryNode
MDL0Node	Model `[get]`

BRRESNode	BRESNode `[get]`

Properties inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
string	FilePath `[get]`

string	FileName `[get]`

string	DirectoryName `[get]`

ResourceNode	RootNode `[get]`

DataSource	OriginalSource `[get]`

DataSource	UncompressedSource `[get]`

DataSource	WorkingSource `[get]`

DataSource	WorkingUncompressed `[get]`

virtual bool	HasChildren `[get]`

virtual ResourceType	ResourceFileType `[get]`

string	NodeType `[get]`

virtual string	TreePathAbsolute `[get]`

virtual string	TreePath `[get]`

virtual int	Level `[get]`

virtual int	MaxNameLength `[get]`

virtual bool	AllowDuplicateNames `[get]`

virtual bool	AllowNullNames `[get]`

virtual string	Name `[get, set]`

ResourceNode	Parent `[get, set]`

List< ResourceNode >	Children `[get]`

int	Index `[get]`

int	HexIndex `[get]`

bool	IsCompressed `[get]`

bool	HasChanged `[get, set]`

bool	IsBranch `[get]`

bool	HasMerged `[get]`

virtual bool	AllowSaving `[get, set]`

virtual bool	IsDirty `[get, set]`

virtual uint	UncompressedSize `[get]`

virtual Type[]	AllowedChildTypes `[get]`

virtual string	Compression `[get, set]`

virtual bool	RetainChildrenOnReplace `[get]`

virtual bool	supportsCompression `[get]`

static MD5CryptoServiceProvider	MD5Provider `[get]`

Properties inherited from BrawlLib.Imaging.IImageSource
int	ImageCount `[get]`

Additional Inherited Members
Static Public Member Functions inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
static ResourceNode[]	FindAllSubNodes (ResourceNode root)

static ResourceNode	FindNode (ResourceNode root, string path, bool searchChildren, StringComparison compare)

Protected Member Functions inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
void	ForceReplacedEvent ()

virtual void	MergeInternal ()

Events inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
SelectEventHandler	SelectChild

EventHandler	UpdateProps

MoveEventHandler	MovedUp

ResourceEventHandler	Disposing

ResourceChildEventHandler	ChildAdded

ResourceChildInsertEventHandler	ChildInserted

Member Enumeration Documentation

◆ IndirectMethod

enum BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectMethod

        {
            Warp = 0,
            NormalMap,
            NormalMapSpecular,
            Fur,
            Reserved0,
            Reserved1,
            User0,
            User1
        }

Constructor & Destructor Documentation

◆ MDL0MaterialNode()

BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.MDL0MaterialNode ( )

inline

        {
            _chan1 = new LightChannel(
                63,
                new RGBAPixel(128, 128, 128, 255),
                new RGBAPixel(255, 255, 255, 255),
                new LightChannelControl(true, GXColorSrc.Register, GXColorSrc.Register, GXDiffuseFn.Clamped,
                    GXAttnFn.Spotlight),
                new LightChannelControl(true, GXColorSrc.Register, GXColorSrc.Register, GXDiffuseFn.Clamped,
                    GXAttnFn.Spotlight),
                this);
            _chan2 = new LightChannel(
                15,
                new RGBAPixel(0, 0, 0, 255),
                new RGBAPixel(),
                0,
                0,
                this);
        }

Member Function Documentation

◆ ApplyViewportLighting()

void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ApplyViewportLighting ( ModelPanelViewport viewport )

inline

        {
            //TODO: support 8 built-in lights instead of just one, and fog?
            //(like an SCN0 built into the program)
            if (!_scn0Applied)
            {
                bool pointLight = viewport._posLight._w != 0.0f;
                _lights[0] = new GLSLLightFrame(
                    viewport._lightEnabled,
                    pointLight ? LightType.Point : LightType.Directional,
                    new Vector3(viewport._posLight._x, viewport._posLight._y, viewport._posLight._z),
                    new Vector3(),
                    viewport.Diffuse,
                    pointLight
                        ? SCN0LightNode.GetLightDistCoefs(viewport.LightPosition._x, 0.5f, DistAttnFn.Medium)
                        : new Vector3(1.0f, 0.0f, 0.0f),
                    new Vector3(1.0f, 0.0f, 0.0f),
                    true,
                    viewport.Specular,
                    SCN0LightNode.GetSpecShineDistCoefs(64.0f));
                _ambientLight = viewport.Ambient;
            }
        }

◆ CheckIfMetal()

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.CheckIfMetal ( )

inline

        {
            if (Model != null && Model._autoMetal)
            {
                if (!_updating)
                {
                    if (IsMetal)
                    {
                        if (MessageBox.Show(null,
                            "This model is currently set to automatically modify metal materials.\nYou cannot make changes unless you turn it off.\nDo you want to turn it off?",
                            "", MessageBoxButtons.YesNo) == DialogResult.Yes)
                        {
                            Model._autoMetal = false;
                        }
                        else
                        {
                            return true;
                        }
                    }
                }
            }
 
            return false;
        }

◆ Export()

override void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Export ( string outPath )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            StringTable table = new StringTable();
            GetStrings(table);
            int dataLen = CalculateSize(false);
            int totalLen = dataLen + table.GetTotalSize();
 
            using (FileStream stream = new FileStream(outPath, FileMode.OpenOrCreate, FileAccess.ReadWrite,
                FileShare.None, 8, FileOptions.RandomAccess))
            {
                stream.SetLength(totalLen);
                using (FileMap map = FileMap.FromStream(stream))
                {
                    Rebuild(map.Address, dataLen, false);
                    table.WriteTable(map.Address + dataLen);
                    PostProcess(map.Address, map.Address, table);
                    ((MDL0Material*) map.Address)->_pad = (byte) Model._version;
                }
            }
        }

◆ GenerateShadowMaterial()

void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.GenerateShadowMaterial ( )

inline

        {
            //HardcodedFiles.CreateShadowMaterial();
            //ReplaceRaw(FileMap.FromFile(ShadowMaterial.Name));
            Name = "MShadow1";
 
            EnableBlend = true;
            LightChannel0.MaterialColor = new Vector4(255 * 255, 255 * 255, 255 * 255, 255 * 255);
            LightChannel0.Color.Enabled = false;
            LightChannel0.Color.MaterialSource = (GXColorSrc) 1;
            LightChannel0.Alpha.Enabled = false;
            LightChannel0.Alpha.MaterialSource = (GXColorSrc) 1;
            XLUMaterial = true;
            LightSetIndex = -1;
            _tevColorBlock.TevReg1Lo.AG = 70;
            CompareBeforeTexture = true;
            EnableDepthUpdate = false;
 
            Children?.Clear();
 
            addShadowReference();
        }

◆ GenerateSpyMaterial()

void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.GenerateSpyMaterial ( )

inline

        {
            //HardcodedFiles.CreateSpyMaterial();
            //ReplaceRaw(FileMap.FromFile(SpyMaterial.Name));
            Name = "Spycloak";
 
            LightSetIndex = -1;
            FogIndex = -1;
            _tevColorBlock.TevReg1Lo.RB = 255;
            _tevColorBlock.TevReg1Hi0.RB = 255;
            _tevColorBlock.TevReg1Hi0.AG = 255;
            IndirectShaderStages = 1;
 
            LightChannel1._matColor.Red = 255;
            LightChannel1._matColor.Blue = 255;
            LightChannel1._matColor.Green = 255;
 
            LightChannel0.Color.Enabled = false;
            LightChannel0.Alpha.Enabled = false;
 
            CompareBeforeTexture = true;
 
            Children?.Clear();
 
            addSpyReferences();
        }

◆ GetImage()

Bitmap BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.GetImage ( int index )

inline

Implements BrawlLib.Imaging.IImageSource.

        {
            return ((IImageSource) Children?.Where(o => o is IImageSource i && i.ImageCount > 0).ToArray()[index])
                .GetImage(0);
        }

◆ OnCalculateSize()

override int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.OnCalculateSize ( bool force )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            int temp, size;
 
            //Add header and tex matrices size at start
            size = 0x414 + (Model._version >= 10 ? 4 : 0);
 
            //Add children size
            size += Children.Count * MDL0TextureRef.Size;
 
            //Add user entries, if there are any
            size += _userEntries.GetSize();
 
            //Set temp align offset
            temp = size;
 
            //Align data to an offset divisible by 0x20 using data length.
            size = size.Align(0x10) + _dataAlign;
            if ((size + _mdlOffset) % 0x20 != 0)
            {
                size += size - 0x10 >= temp ? -0x10 : 0x10;
            }
 
            //Reset data alignment
            _dataAlign = 0;
 
            //Add display list and XF flags
            size += 0x180;
 
            return size;
        }

◆ OnInitialize()

override bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.OnInitialize ( )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            MDL0Material* header = Header;
 
            _initVersion = header->_pad != 0 && _replaced ? header->_pad : Model._version;
 
            if (_name == null && header->_stringOffset != 0)
            {
                _name = header->ResourceString;
            }
 
            //Get XF Commands
            XFCmds = XFData.Parse((byte*) header->DisplayLists(_initVersion) + 0xE0);
 
            _usageFlags = header->_usageFlags;
 
            _indirectMethod1 = header->_indirectMethod1;
            _indirectMethod2 = header->_indirectMethod2;
            _indirectMethod3 = header->_indirectMethod3;
            _indirectMethod4 = header->_indirectMethod4;
 
            _normMapRefLight1 = header->_normMapRefLight1;
            _normMapRefLight2 = header->_normMapRefLight2;
            _normMapRefLight3 = header->_normMapRefLight3;
            _normMapRefLight4 = header->_normMapRefLight4;
 
            _activeStages = header->_activeTEVStages;
            _activeIndStages = header->_numIndTexStages;
            _depthTestBeforeTexture = header->_depthTestBeforeTexture;
 
            _lightSetIndex = header->_lightSet;
            _fogIndex = header->_fogSet;
 
            _cull = (CullMode) (int) header->_cull;
 
            if (!_replaced && (-header->_mdl0Offset + header->DisplayListOffset(_initVersion)) % 0x20 != 0)
            {
                Model._errors.Add("Material " + Index + " has an improper align offset.");
            }
 
            MatModeBlock* mode = header->DisplayLists(_initVersion);
            _alphaFunc = mode->AlphaFunction;
            _zMode = mode->ZMode;
            _blendMode = mode->BlendMode;
            _constantAlpha = mode->ConstantAlpha;
 
            _tevColorBlock = *header->TevColorBlock(_initVersion);
            _tevKonstBlock = *header->TevKonstBlock(_initVersion);
            _indMtx = *header->IndMtxBlock(_initVersion);
 
            MDL0TexSRTData* TexMatrices = header->TexMatrices(_initVersion);
            _texMtxFlags = TexMatrices->_mtxFlags;
 
            MDL0MaterialLighting* Light = header->Light(_initVersion);
 
            (_chan1 = Light->Channel1)._parent = this;
            (_chan2 = Light->Channel2)._parent = this;
 
            (_userEntries = new UserDataCollection()).Read(header->UserData(_initVersion), WorkingUncompressed);
 
            return true;
        }

◆ OnPopulate()

override void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.OnPopulate ( )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            MDL0TextureRef* first = Header->First;
            for (int i = 0; i < Header->_numTextures; i++)
            {
                new MDL0MaterialRefNode().Initialize(this, first++, MDL0TextureRef.Size);
            }
        }

◆ OnRebuild()

override void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.OnRebuild	(	VoidPtr	address,
		int	length,
		bool	force
	)

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            MDL0Node model = Model;
            MDL0Material* header = (MDL0Material*) address;
 
            //Set offsets
            header->_dataLen = length;
 
            int addr = 0x414, displayListOffset = length - 0x180;
            if (model._version >= 10)
            {
                addr += 4;
 
                header->_dataOffset2 = 0; //Fur Data not supported
                header->_dataOffset3 = displayListOffset;
            }
            else
            {
                header->_dataOffset2 = displayListOffset;
            }
 
            header->_matRefOffset = Children.Count > 0 ? addr : 0;
 
            //Check for user entries
            if (_userEntries.Count > 0)
            {
                addr += Children.Count * 0x34;
                if (model._version >= 10)
                {
                    header->_dataOffset2 = addr;
                }
                else
                {
                    header->_dataOffset1 = addr;
                }
 
                _userEntries.Write(header->UserData(model._version));
            }
            else
            {
                header->_dataOffset1 = 0;
            }
 
            ushort i1 = 0x1040, i2 = 0x1050, mtx = 0;
            if (Model._isImport)
            {
                //Set default texgen flags
                for (int i = 0; i < Children.Count; i++, mtx += 3, i1++, i2++)
                {
                    MDL0MaterialRefNode node = (MDL0MaterialRefNode) Children[i];
 
                    node._bindState = TextureFrameState.Neutral;
                    node._texMatrixEffect.TextureMatrix = Matrix34.Identity;
                    node._texMatrixEffect.SCNCamera = -1;
                    node._texMatrixEffect.SCNLight = -1;
                    node._texMatrixEffect.MapMode = MappingMethod.TexCoord;
 
                    node._dualTexFlags = new XFDualTex(mtx, 0);
                    node._texMtxFlags = new XFTexMtxInfo(
                        TexProjection.ST,
                        TexInputForm.AB11,
                        TexTexgenType.Regular,
                        TexSourceRow.TexCoord0,
                        5, 0);
 
                    XFCmds.Add(new XFData(i1, node._texMtxFlags._data));
                    XFCmds.Add(new XFData(i2, node._dualTexFlags.Value));
                }
            }
 
            //Set header values
            header->_numTextures = Children.Count;
            header->_numTexGens = (byte) Children.Count;
            header->_index = Index;
            header->_activeTEVStages = _activeStages;
            header->_numIndTexStages = _activeIndStages;
            header->_depthTestBeforeTexture = _depthTestBeforeTexture;
 
            byte lights = 0;
            if (_chan1.RasterColorEnabled || _chan1.RasterAlphaEnabled)
            {
                lights++;
            }
 
            if (_chan2.RasterColorEnabled || _chan2.RasterAlphaEnabled)
            {
                lights++;
            }
 
            header->_numLightChans = lights;
 
            header->_lightSet = _lightSetIndex;
            header->_fogSet = _fogIndex;
            header->_pad = 0;
 
            header->_cull = (int) _cull;
            header->_usageFlags = _usageFlags;
 
            header->_indirectMethod1 = _indirectMethod1;
            header->_indirectMethod2 = _indirectMethod2;
            header->_indirectMethod3 = _indirectMethod3;
            header->_indirectMethod4 = _indirectMethod4;
 
            header->_normMapRefLight1 = _normMapRefLight1;
            header->_normMapRefLight2 = _normMapRefLight2;
            header->_normMapRefLight3 = _normMapRefLight3;
            header->_normMapRefLight4 = _normMapRefLight4;
 
            //Generate layer flags and write texture matrices
            MDL0TexSRTData* TexSettings = header->TexMatrices(model._version);
            *TexSettings = MDL0TexSRTData.Default;
 
            //Usage flags. Each set of 4 bits represents one texture layer.
            uint layerFlags = 0;
 
            //Loop through references in reverse so that layerflags is set in the right order
            for (int i = Children.Count - 1; i >= 0; i--)
            {
                MDL0MaterialRefNode node = (MDL0MaterialRefNode) Children[i];
 
                TexFlags flags = TexFlags.Enabled;
 
                //Check for non-default values
                if (node._bindState.Scale == new Vector2(1))
                {
                    flags |= TexFlags.FixedScale;
                }
 
                if (node._bindState.Rotate == 0)
                {
                    flags |= TexFlags.FixedRot;
                }
 
                if (node._bindState.Translate == new Vector2(0))
                {
                    flags |= TexFlags.FixedTrans;
                }
 
                TexSettings->SetTexSRT(node._bindState, node.Index);
                TexSettings->SetTexMatrices(node._texMatrixEffect, node.Index);
 
                layerFlags = (layerFlags << 4) | (byte) flags;
            }
 
            TexSettings->_layerFlags = layerFlags;
            TexSettings->_mtxFlags = _texMtxFlags;
 
            //Write lighting flags
            MDL0MaterialLighting* Light = header->Light(model._version);
 
            Light->Channel1 = _chan1;
            Light->Channel2 = _chan2;
 
            //The shader offset will be written later
 
            //Rebuild references
            MDL0TextureRef* mRefs = header->First;
            foreach (MDL0MaterialRefNode n in Children)
            {
                n.Rebuild(mRefs++, MDL0TextureRef.Size, true);
            }
 
            //Set Display Lists
            *header->TevKonstBlock(model._version) = _tevKonstBlock;
            *header->TevColorBlock(model._version) = _tevColorBlock;
            *header->IndMtxBlock(model._version) = _indMtx;
 
            MatModeBlock* mode = header->DisplayLists(model._version);
            *mode = MatModeBlock.Default;
            if (model._isImport)
            {
                _alphaFunc = mode->AlphaFunction;
                _zMode = mode->ZMode;
                _blendMode = mode->BlendMode;
                _constantAlpha = mode->ConstantAlpha;
            }
            else
            {
                mode->AlphaFunction = _alphaFunc;
                mode->ZMode = _zMode;
                mode->BlendMode = _blendMode;
                mode->ConstantAlpha = _constantAlpha;
            }
 
            //Write XF flags
            i1 = 0x1040;
            i2 = 0x1050;
            mtx = 0;
            byte* xfData = (byte*) header->DisplayLists(model._version) + 0xE0;
            foreach (MDL0MaterialRefNode mr in Children)
            {
                //Tex Mtx
                *xfData++ = 0x10;
                *(bushort*) xfData = 0;
                xfData += 2;
                *(bushort*) xfData = i1++;
                xfData += 2;
                *(buint*) xfData = mr._texMtxFlags._data._data;
                xfData += 4;
 
                //Dual Tex
                *xfData++ = 0x10;
                *(bushort*) xfData = 0;
                xfData += 2;
                *(bushort*) xfData = i2++;
                xfData += 2;
                *(buint*) xfData = new XFDualTex(mtx, mr._dualTexFlags._normalEnable).Value;
                xfData += 4;
 
                mtx += 3;
            }
        }

◆ Remove() [1/2]

override void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Remove ( )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            Remove(ShaderNode != null && ShaderNode.Materials.Length == 1 &&
                   MessageBox.Show("Do you want to remove this material's shader?", "", MessageBoxButtons.YesNo) ==
                   DialogResult.Yes);
        }

◆ Remove() [2/2]

void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Remove ( bool removeAttached )

inline

        {
            if (Parent != null)
            {
                if (removeAttached)
                {
                    ShaderNode?.Remove();
                }
 
                ShaderNode = null;
 
                foreach (MDL0MaterialRefNode r in Children)
                {
                    r.TextureNode = null;
                    r.PaletteNode = null;
                }
 
                Model.CheckTextures();
            }
 
            base.Remove();
        }

◆ Replace()

override void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Replace ( string fileName )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            base.Replace(fileName);
 
            Model?.CheckTextures();
        }

◆ SignalPropertyChange()

override void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.SignalPropertyChange ( )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.MDL0EntryNode.

        {
            _fragShaderSource = null;
            _vertexShaderSource = null;
 
            if (Model != null && Model.AutoMetalMaterials && !IsMetal)
            {
                Model.GenerateMetalMaterials();
            }
 
            base.SignalPropertyChange();
        }

◆ UpdateAsMetal()

void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.UpdateAsMetal ( )

inline

        {
            if (!IsMetal)
            {
                return;
            }
 
            _updating = true;
            if (ShaderNode != null && ShaderNode._autoMetal && ShaderNode._texCount == Children.Count)
            {
                //ShaderNode.DefaultAsMetal(Children.Count); 
            }
            else
            {
                bool found = false;
                foreach (MDL0ShaderNode s in Model._shadList)
                {
                    if (s._autoMetal && s._texCount == Children.Count)
                    {
                        ShaderNode = s;
                        found = true;
                    }
                    else
                    {
                        if (s.Stages == 4)
                        {
                            foreach (MDL0MaterialNode y in s._materials)
                            {
                                if (!y.IsMetal || y.Children.Count != Children.Count)
                                {
                                    goto NotFound;
                                }
                            }
 
                            ShaderNode = s;
                            found = true;
                            goto End;
                            NotFound:
                            continue;
                        }
                    }
                }
 
                End:
                if (!found)
                {
                    MDL0ShaderNode shader = new MDL0ShaderNode();
                    Model._shadGroup.AddChild(shader);
                    shader.DefaultAsMetal(Children.Count);
                    ShaderNode = shader;
                }
            }
 
            if (MetalMaterial != null)
            {
                Name = MetalMaterial.Name + "_ExtMtl";
                _activeStages = 4;
 
                if (Children.Count - 1 != MetalMaterial.Children.Count)
                {
                    //Remove all children
                    for (int i = 0; i < Children.Count; i++)
                    {
                        ((MDL0MaterialRefNode) Children[i]).TextureNode = null;
                        ((MDL0MaterialRefNode) Children[i]).PaletteNode = null;
                        RemoveChild(Children[i--]);
                    }
 
                    //Start over
                    for (int i = 0; i <= MetalMaterial.Children.Count; i++)
                    {
                        MDL0MaterialRefNode mr = new MDL0MaterialRefNode();
 
                        AddChild(mr);
                        mr.Texture = "metal00";
 
                        mr._bindState = TextureFrameState.Neutral;
                        mr._texMatrixEffect.TextureMatrix = Matrix34.Identity;
                        mr._texMatrixEffect.SCNCamera = -1;
                        mr._texMatrixEffect.SCNLight = -1;
 
                        XFTexMtxInfo info = new XFTexMtxInfo
                        {
                            Projection = TexProjection.STQ,
                            InputForm = TexInputForm.ABC1,
                            TexGenType = TexTexgenType.Regular,
                            SourceRow = TexSourceRow.Normals,
                            EmbossSource = 5,
                            EmbossLight = 0
                        };
 
                        if (i == MetalMaterial.Children.Count)
                        {
                            mr._minFltr = 5;
                            mr._magFltr = 1;
                            mr._lodBias = -2;
                            mr.HasTextureMatrix = true;
                            info.Projection = TexProjection.STQ;
                            info.InputForm = TexInputForm.ABC1;
                            info.SourceRow = TexSourceRow.Normals;
                            mr.Normalize = true;
                            mr.MapMode = MappingMethod.EnvCamera;
                        }
                        else
                        {
                            info.Projection = TexProjection.ST;
                            info.InputForm = TexInputForm.AB11;
                            info.SourceRow = TexSourceRow.TexCoord0 + i;
                            mr.Normalize = false;
                            mr.MapMode = MappingMethod.TexCoord;
                        }
 
                        info.TexGenType = TexTexgenType.Regular;
                        info.EmbossSource = 5;
                        info.EmbossLight = 0;
 
                        mr._texMtxFlags = info;
                    }
 
                    _chan1 = new LightChannel(63, new RGBAPixel(128, 128, 128, 255), new RGBAPixel(255, 255, 255, 255),
                        0, 0, this);
                    C1ColorEnabled = true;
                    C1ColorDiffuseFunction = GXDiffuseFn.Clamped;
                    C1ColorAttenuation = GXAttnFn.Spotlight;
                    C1AlphaEnabled = true;
                    C1AlphaDiffuseFunction = GXDiffuseFn.Clamped;
                    C1AlphaAttenuation = GXAttnFn.Spotlight;
 
                    _chan2 = new LightChannel(63, new RGBAPixel(255, 255, 255, 255), new RGBAPixel(), 0, 0, this);
                    C2ColorEnabled = true;
                    C2ColorDiffuseFunction = GXDiffuseFn.Disabled;
                    C2ColorAttenuation = GXAttnFn.Specular;
                    C2AlphaDiffuseFunction = GXDiffuseFn.Disabled;
                    C2AlphaAttenuation = GXAttnFn.Specular;
 
                    _lightSetIndex = MetalMaterial._lightSetIndex;
                    _fogIndex = MetalMaterial._fogIndex;
 
                    _cull = MetalMaterial._cull;
                    //_numLights = 2;
                    CompareBeforeTexture = true;
                    _normMapRefLight1 =
                        _normMapRefLight2 =
                            _normMapRefLight3 =
                                _normMapRefLight4 = -1;
 
                    SignalPropertyChange();
                }
            }
 
            _updating = false;
        }

◆ UseProgram()

void BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.UseProgram	(	MDL0ObjectNode	node,
		bool	forceRemake = `false`
	)

inline

        {
            forceRemake = forceRemake || ShaderGenerator._forceRecompile;
 
            //If a rendering property has been changed, the shaders need to be regenerated
            bool updateVert = string.IsNullOrEmpty(_vertexShaderSource) || forceRemake;
            bool updateMatFrag = string.IsNullOrEmpty(_fragShaderSource) || forceRemake;
            bool updateShaderFrag = ShaderNode != null && ShaderNode._fragShaderSource == null || forceRemake;
            bool updateProgram = _programHandle <= 0 ||
                                 updateVert || _vertexShaderHandle <= 0 ||
                                 updateMatFrag || updateShaderFrag || _fragShaderHandle <= 0 ||
                                 _internalForceRemake;
 
            if (updateShaderFrag)
            {
                foreach (MDL0MaterialNode m in ShaderNode.Materials)
                {
                    m._internalForceRemake = true;
                }
            }
 
            _internalForceRemake = false;
 
            if (updateProgram)
            {
#if !DEBUG
                try
                {
#endif
                if (_programHandle > 0)
                {
                    if (_vertexShaderHandle > 0)
                    {
                        DeleteShader(ref _vertexShaderHandle);
                    }
 
                    if (_fragShaderHandle > 0)
                    {
                        DeleteShader(ref _fragShaderHandle);
                    }
 
                    GL.DeleteProgram(_programHandle);
                    _programHandle = 0;
                }
 
                ShaderGenerator.SetTarget(this);
 
                if (updateShaderFrag)
                {
                    ShaderNode._fragShaderSource = ShaderGenerator.GenTEVFragShader();
                }
 
                if (updateVert)
                {
                    _vertexShaderSource = ShaderGenerator.GenVertexShader();
                }
 
                if (updateMatFrag)
                {
                    _fragShaderSource = ShaderGenerator.GenMaterialFragShader();
                }
 
                string combineFrag = ShaderGenerator.CombineFragShader(
                    _fragShaderSource,
                    ShaderNode == null ? null : ShaderNode._fragShaderSource,
                    ActiveShaderStages);
 
                GenShader(ref _vertexShaderHandle, _vertexShaderSource, true);
                GenShader(ref _fragShaderHandle, combineFrag, false);
 
                ShaderGenerator.ClearTarget();
 
                _programHandle = GL.CreateProgram();
 
                GL.AttachShader(_programHandle, _vertexShaderHandle);
                GL.AttachShader(_programHandle, _fragShaderHandle);
 
                GL.LinkProgram(_programHandle);
 
#if DEBUG
                GL.GetProgram(_programHandle, ProgramParameter.LinkStatus, out int status);
                if (status == 0)
                {
                    string log = GL.GetProgramInfoLog(_programHandle);
                    Console.WriteLine(log);
                }
#else
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.ToString());
                }
#endif
            }
 
            GL.UseProgram(_programHandle);
            ShaderGenerator.SetUniforms(this);
        }

Member Data Documentation

◆ _activeIndStages

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._activeIndStages

◆ _activeStages

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._activeStages

◆ _alphaFunc

GXAlphaFunction BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._alphaFunc = GXAlphaFunction.Default

◆ _ambientLight

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._ambientLight

◆ _blendMode

BlendMode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._blendMode = BlendMode.Default

◆ _chan1

LightChannel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._chan1

◆ _chan2

LightChannel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._chan2

◆ _constantAlpha

ConstantAlpha BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._constantAlpha = ConstantAlpha.Default

◆ _cull

CullMode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._cull = CullMode.Cull_Inside

◆ _depthTestBeforeTexture

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._depthTestBeforeTexture

◆ _fog

FogAnimationFrame BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._fog

◆ _fogIndex

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._fogIndex = 4

◆ _fragShaderHandle

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._fragShaderHandle

◆ _fragShaderSource

string BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._fragShaderSource

◆ _indirectFrameStates

TextureFrameState [] BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._indirectFrameStates = new TextureFrameState[3]

◆ _indirectMethod1

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._indirectMethod1

◆ _indirectMethod2

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._indirectMethod2

◆ _indirectMethod3

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._indirectMethod3

◆ _indirectMethod4

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._indirectMethod4

◆ _indMtx

MatIndMtxBlock BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._indMtx = MatIndMtxBlock.Default

◆ _internalForceRemake

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._internalForceRemake

◆ _lights

GLSLLightFrame [] BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._lights = new GLSLLightFrame[8]

◆ _lightSetIndex

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._lightSetIndex = 20

◆ _normMapRefLight1

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._normMapRefLight1 = -1

◆ _normMapRefLight2

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._normMapRefLight2 = -1

◆ _normMapRefLight3

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._normMapRefLight3 = -1

◆ _normMapRefLight4

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._normMapRefLight4 = -1

◆ _objects

List<MDL0ObjectNode> BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._objects = new List<MDL0ObjectNode>()

◆ _programHandle

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._programHandle

◆ _scn0Applied

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._scn0Applied

◆ _tevColorBlock

MatTevColorBlock BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._tevColorBlock = MatTevColorBlock.Default

◆ _tevKonstBlock

MatTevKonstBlock BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._tevKonstBlock = MatTevKonstBlock.Default

◆ _texMtxFlags

uint BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._texMtxFlags

◆ _updating

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._updating

◆ _vertexShaderHandle

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._vertexShaderHandle

◆ _vertexShaderSource

string BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._vertexShaderSource

◆ _zMode

ZMode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode._zMode = ZMode.Default

◆ amb1

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.amb1

◆ amb2

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.amb2

◆ c1

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.c1

◆ c2

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.c2

◆ c3

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.c3

◆ clr1

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.clr1

◆ clr2

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.clr2

◆ k1

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.k1

◆ k2

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.k2

◆ k3

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.k3

◆ k4

Vector4 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.k4

◆ XFCmds

List<XFData> BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.XFCmds = new List<XFData>()

Property Documentation

◆ ActiveShaderStages

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ActiveShaderStages

getset

        {
            get => _activeStages;
            set
            {
                if (!CheckIfMetal())
                {
                    _activeStages = (byte) (value > ShaderNode.Stages ? ShaderNode.Stages : value < 1 ? 1 : value);
                    SignalPropertyChange();
                }
            }
        }

◆ AllowDuplicateNames

override bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.AllowDuplicateNames

get

◆ BlendLogicOp

GXLogicOp BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.BlendLogicOp

getset

        {
            get => _blendMode.LogicOp;
            set
            {
                if (!CheckIfMetal())
                {
                    _blendMode.LogicOp = value;
                    SignalPropertyChange();
                }
            }
        }

◆ C1AlphaAmbientSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AlphaAmbientSource

getset

        {
            get => _chan1.AlphaAmbientSource;
            set => _chan1.AlphaAmbientSource = value;
        }

◆ C1AlphaAttenuation

GXAttnFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AlphaAttenuation

getset

        {
            get => _chan1.AlphaAttenuation;
            set => _chan1.AlphaAttenuation = value;
        }

◆ C1AlphaDiffuseFunction

GXDiffuseFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AlphaDiffuseFunction

getset

        {
            get => _chan1.AlphaDiffuseFunction;
            set => _chan1.AlphaDiffuseFunction = value;
        }

◆ C1AlphaEnabled

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AlphaEnabled

getset

        {
            get => _chan1.AlphaEnabled;
            set => _chan1.AlphaEnabled = value;
        }

◆ C1AlphaLights

MatChanLights BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AlphaLights

getset

        {
            get => _chan1.AlphaLights;
            set => _chan1.AlphaLights = value;
        }

◆ C1AlphaMaterialSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AlphaMaterialSource

getset

        {
            get => _chan1.AlphaMaterialSource;
            set => _chan1.AlphaMaterialSource = value;
        }

◆ C1AmbientColor

RGBAPixel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1AmbientColor

getset

        {
            get => _chan1.AmbientColor;
            set => _chan1.AmbientColor = value;
        }

◆ C1ColorAmbientSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1ColorAmbientSource

getset

        {
            get => _chan1.ColorAmbientSource;
            set => _chan1.ColorAmbientSource = value;
        }

◆ C1ColorAttenuation

GXAttnFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1ColorAttenuation

getset

        {
            get => _chan1.ColorAttenuation;
            set => _chan1.ColorAttenuation = value;
        }

◆ C1ColorDiffuseFunction

GXDiffuseFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1ColorDiffuseFunction

getset

        {
            get => _chan1.ColorDiffuseFunction;
            set => _chan1.ColorDiffuseFunction = value;
        }

◆ C1ColorEnabled

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1ColorEnabled

getset

        {
            get => _chan1.ColorEnabled;
            set => _chan1.ColorEnabled = value;
        }

◆ C1ColorLights

MatChanLights BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1ColorLights

getset

        {
            get => _chan1.ColorLights;
            set => _chan1.ColorLights = value;
        }

◆ C1ColorMaterialSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1ColorMaterialSource

getset

        {
            get => _chan1.ColorMaterialSource;
            set => _chan1.ColorMaterialSource = value;
        }

◆ C1Flags

LightingChannelFlags BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1Flags

getset

        {
            get => _chan1.Flags;
            set => _chan1.Flags = value;
        }

◆ C1MaterialColor

RGBAPixel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C1MaterialColor

getset

        {
            get => _chan1.MaterialColor;
            set => _chan1.MaterialColor = value;
        }

◆ C2AlphaAmbientSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AlphaAmbientSource

getset

        {
            get => _chan2.AlphaAmbientSource;
            set => _chan2.AlphaAmbientSource = value;
        }

◆ C2AlphaAttenuation

GXAttnFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AlphaAttenuation

getset

        {
            get => _chan2.AlphaAttenuation;
            set => _chan2.AlphaAttenuation = value;
        }

◆ C2AlphaDiffuseFunction

GXDiffuseFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AlphaDiffuseFunction

getset

        {
            get => _chan2.AlphaDiffuseFunction;
            set => _chan2.AlphaDiffuseFunction = value;
        }

◆ C2AlphaEnabled

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AlphaEnabled

getset

        {
            get => _chan2.AlphaEnabled;
            set => _chan2.AlphaEnabled = value;
        }

◆ C2AlphaLights

MatChanLights BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AlphaLights

getset

        {
            get => _chan2.AlphaLights;
            set => _chan2.AlphaLights = value;
        }

◆ C2AlphaMaterialSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AlphaMaterialSource

getset

        {
            get => _chan2.AlphaMaterialSource;
            set => _chan2.AlphaMaterialSource = value;
        }

◆ C2AmbientColor

RGBAPixel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2AmbientColor

getset

        {
            get => _chan2.AmbientColor;
            set => _chan2.AmbientColor = value;
        }

◆ C2ColorAmbientSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2ColorAmbientSource

getset

        {
            get => _chan2.ColorAmbientSource;
            set => _chan2.ColorAmbientSource = value;
        }

◆ C2ColorAttenuation

GXAttnFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2ColorAttenuation

getset

        {
            get => _chan2.ColorAttenuation;
            set => _chan2.ColorAttenuation = value;
        }

◆ C2ColorDiffuseFunction

GXDiffuseFn BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2ColorDiffuseFunction

getset

        {
            get => _chan2.ColorDiffuseFunction;
            set => _chan2.ColorDiffuseFunction = value;
        }

◆ C2ColorEnabled

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2ColorEnabled

getset

        {
            get => _chan2.ColorEnabled;
            set => _chan2.ColorEnabled = value;
        }

◆ C2ColorLights

MatChanLights BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2ColorLights

getset

        {
            get => _chan2.ColorLights;
            set => _chan2.ColorLights = value;
        }

◆ C2ColorMaterialSource

GXColorSrc BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2ColorMaterialSource

getset

        {
            get => _chan2.ColorMaterialSource;
            set => _chan2.ColorMaterialSource = value;
        }

◆ C2Flags

LightingChannelFlags BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2Flags

getset

        {
            get => _chan2.Flags;
            set => _chan2.Flags = value;
        }

◆ C2MaterialColor

RGBAPixel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.C2MaterialColor

getset

        {
            get => _chan2.MaterialColor;
            set => _chan2.MaterialColor = value;
        }

◆ Color0

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Color0

getset

        {
            get => new GXColorS10
            {
                R = _tevColorBlock.TevReg1Lo.RB, A = _tevColorBlock.TevReg1Lo.AG, B = _tevColorBlock.TevReg1Hi0.RB,
                G = _tevColorBlock.TevReg1Hi0.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevColorBlock.TevReg1Lo.RB = value.R;
                    _tevColorBlock.TevReg1Lo.AG = value.A;
 
                    //High values are always the same...
                    _tevColorBlock.TevReg1Hi0.RB =
                        _tevColorBlock.TevReg1Hi1.RB =
                            _tevColorBlock.TevReg1Hi2.RB = value.B;
                    _tevColorBlock.TevReg1Hi0.AG =
                        _tevColorBlock.TevReg1Hi1.AG =
                            _tevColorBlock.TevReg1Hi2.AG = value.G;
 
                    c1 = value;
 
                    SignalPropertyChange();
                }
            }
        }

◆ Color1

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Color1

getset

        {
            get => new GXColorS10
            {
                R = _tevColorBlock.TevReg2Lo.RB, A = _tevColorBlock.TevReg2Lo.AG, B = _tevColorBlock.TevReg2Hi0.RB,
                G = _tevColorBlock.TevReg2Hi0.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevColorBlock.TevReg2Lo.RB = value.R;
                    _tevColorBlock.TevReg2Lo.AG = value.A;
 
                    //High values are always the same...
                    _tevColorBlock.TevReg2Hi0.RB =
                        _tevColorBlock.TevReg2Hi1.RB =
                            _tevColorBlock.TevReg2Hi2.RB = value.B;
                    _tevColorBlock.TevReg2Hi0.AG =
                        _tevColorBlock.TevReg2Hi1.AG =
                            _tevColorBlock.TevReg2Hi2.AG = value.G;
 
                    c2 = value;
 
                    SignalPropertyChange();
                }
            }
        }

◆ Color2

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Color2

getset

        {
            get => new GXColorS10
            {
                R = _tevColorBlock.TevReg3Lo.RB, A = _tevColorBlock.TevReg3Lo.AG, B = _tevColorBlock.TevReg3Hi0.RB,
                G = _tevColorBlock.TevReg3Hi0.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevColorBlock.TevReg3Lo.RB = value.R;
                    _tevColorBlock.TevReg3Lo.AG = value.A;
 
                    //High values are always the same...
                    _tevColorBlock.TevReg3Hi0.RB =
                        _tevColorBlock.TevReg3Hi1.RB =
                            _tevColorBlock.TevReg3Hi2.RB = value.B;
                    _tevColorBlock.TevReg3Hi0.AG =
                        _tevColorBlock.TevReg3Hi1.AG =
                            _tevColorBlock.TevReg3Hi2.AG = value.G;
 
                    c3 = value;
 
                    SignalPropertyChange();
                }
            }
        }

◆ Comp0

AlphaCompare BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Comp0

getset

        {
            get => _alphaFunc.Comp0;
            set
            {
                if (!CheckIfMetal())
                {
                    _alphaFunc.Comp0 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ Comp1

AlphaCompare BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Comp1

getset

        {
            get => _alphaFunc.Comp1;
            set
            {
                if (!CheckIfMetal())
                {
                    _alphaFunc.Comp1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ CompareBeforeTexture

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.CompareBeforeTexture

getset

        {
            get => _depthTestBeforeTexture != 0;
            set
            {
                if (!CheckIfMetal())
                {
                    _depthTestBeforeTexture = (byte) (value ? 1 : 0);
                    SignalPropertyChange();
                }
            }
        }

◆ ConstantAlphaEnabled

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ConstantAlphaEnabled

getset

        {
            get => _constantAlpha.Enable != 0;
            set
            {
                if (!CheckIfMetal())
                {
                    _constantAlpha.Enable = (byte) (value ? 1 : 0);
                    SignalPropertyChange();
                }
            }
        }

◆ ConstantAlphaValue

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ConstantAlphaValue

getset

        {
            get => _constantAlpha.Value;
            set
            {
                if (!CheckIfMetal())
                {
                    _constantAlpha.Value = value;
                    SignalPropertyChange();
                }
            }
        }

◆ ConstantColor0

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ConstantColor0

getset

        {
            get => new GXColorS10
            {
                R = _tevKonstBlock.TevReg0Lo.RB, A = _tevKonstBlock.TevReg0Lo.AG, B = _tevKonstBlock.TevReg0Hi.RB,
                G = _tevKonstBlock.TevReg0Hi.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevKonstBlock.TevReg0Lo.RB = value.R;
                    _tevKonstBlock.TevReg0Lo.AG = value.A;
                    _tevKonstBlock.TevReg0Hi.RB = value.B;
                    _tevKonstBlock.TevReg0Hi.AG = value.G;
                    k1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ ConstantColor1

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ConstantColor1

getset

        {
            get => new GXColorS10
            {
                R = _tevKonstBlock.TevReg1Lo.RB, A = _tevKonstBlock.TevReg1Lo.AG, B = _tevKonstBlock.TevReg1Hi.RB,
                G = _tevKonstBlock.TevReg1Hi.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevKonstBlock.TevReg1Lo.RB = value.R;
                    _tevKonstBlock.TevReg1Lo.AG = value.A;
                    _tevKonstBlock.TevReg1Hi.RB = value.B;
                    _tevKonstBlock.TevReg1Hi.AG = value.G;
                    k2 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ ConstantColor2

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ConstantColor2

getset

        {
            get => new GXColorS10
            {
                R = _tevKonstBlock.TevReg2Lo.RB, A = _tevKonstBlock.TevReg2Lo.AG, B = _tevKonstBlock.TevReg2Hi.RB,
                G = _tevKonstBlock.TevReg2Hi.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevKonstBlock.TevReg2Lo.RB = value.R;
                    _tevKonstBlock.TevReg2Lo.AG = value.A;
                    _tevKonstBlock.TevReg2Hi.RB = value.B;
                    _tevKonstBlock.TevReg2Hi.AG = value.G;
                    k3 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ ConstantColor3

GXColorS10 BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ConstantColor3

getset

        {
            get => new GXColorS10
            {
                R = _tevKonstBlock.TevReg3Lo.RB, A = _tevKonstBlock.TevReg3Lo.AG, B = _tevKonstBlock.TevReg3Hi.RB,
                G = _tevKonstBlock.TevReg3Hi.AG
            };
            set
            {
                if (!CheckIfMetal())
                {
                    _tevKonstBlock.TevReg3Lo.RB = value.R;
                    _tevKonstBlock.TevReg3Lo.AG = value.A;
                    _tevKonstBlock.TevReg3Hi.RB = value.B;
                    _tevKonstBlock.TevReg3Hi.AG = value.G;
                    k4 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ CullMode

CullMode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.CullMode

getset

        {
            get => _cull;
            set
            {
                if (!CheckIfMetal())
                {
                    _cull = value;
                    SignalPropertyChange();
                }
            }
        }

◆ DepthFunction

GXCompare BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.DepthFunction

getset

        {
            get => _zMode.DepthFunction;
            set
            {
                if (!CheckIfMetal())
                {
                    _zMode.DepthFunction = value;
                    SignalPropertyChange();
                }
            }
        }

◆ DstFactor

BlendFactor BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.DstFactor

getset

        {
            get => _blendMode.DstFactor;
            set
            {
                if (!CheckIfMetal())
                {
                    _blendMode.DstFactor = value;
                    SignalPropertyChange();
                }
            }
        }

◆ EnableBlend

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.EnableBlend

getset

        {
            get => _blendMode.EnableBlend;
            set
            {
                if (!CheckIfMetal())
                {
                    _blendMode.EnableBlend = value;
                    SignalPropertyChange();
                }
            }
        }

◆ EnableBlendLogic

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.EnableBlendLogic

getset

        {
            get => _blendMode.EnableLogicOp;
            set
            {
                if (!CheckIfMetal())
                {
                    _blendMode.EnableLogicOp = value;
                    SignalPropertyChange();
                }
            }
        }

◆ EnableDepthTest

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.EnableDepthTest

getset

        {
            get => _zMode.EnableDepthTest;
            set
            {
                if (!CheckIfMetal())
                {
                    _zMode.EnableDepthTest = value;
                    SignalPropertyChange();
                }
            }
        }

◆ EnableDepthUpdate

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.EnableDepthUpdate

getset

        {
            get => _zMode.EnableDepthUpdate;
            set
            {
                if (!CheckIfMetal())
                {
                    _zMode.EnableDepthUpdate = value;
                    SignalPropertyChange();
                }
            }
        }

◆ FogIndex

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.FogIndex

getset

        {
            get => _fogIndex;
            set
            {
                if (!CheckIfMetal())
                {
                    _fogIndex = value;
                    MetalMaterial?.UpdateAsMetal();
 
                    SignalPropertyChange();
                }
            }
        }

◆ ID

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ID

get

◆ ImageCount

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ImageCount

get

Implements BrawlLib.Imaging.IImageSource.

◆ IndirectMethodTex1

IndirectMethod BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectMethodTex1

getset

        {
            get => (IndirectMethod) _indirectMethod1;
            set
            {
                if (!CheckIfMetal())
                {
                    _indirectMethod1 = (byte) value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectMethodTex2

IndirectMethod BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectMethodTex2

getset

        {
            get => (IndirectMethod) _indirectMethod2;
            set
            {
                if (!CheckIfMetal())
                {
                    _indirectMethod2 = (byte) value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectMethodTex3

IndirectMethod BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectMethodTex3

getset

        {
            get => (IndirectMethod) _indirectMethod3;
            set
            {
                if (!CheckIfMetal())
                {
                    _indirectMethod3 = (byte) value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectMethodTex4

IndirectMethod BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectMethodTex4

getset

        {
            get => (IndirectMethod) _indirectMethod4;
            set
            {
                if (!CheckIfMetal())
                {
                    _indirectMethod4 = (byte) value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectShaderStages

int BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectShaderStages

getset

        {
            get => _activeIndStages;
            set
            {
                if (!CheckIfMetal())
                {
                    _activeIndStages = (byte) (value > 4 ? 4 : value < 0 ? 0 : value);
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex1ScaleS

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex1ScaleS

getset

        {
            get => _indMtx.SS0val.S_Scale0;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS0val.S_Scale0 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex1ScaleT

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex1ScaleT

getset

        {
            get => _indMtx.SS0val.T_Scale0;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS0val.T_Scale0 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex2ScaleS

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex2ScaleS

getset

        {
            get => _indMtx.SS0val.S_Scale1;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS0val.S_Scale1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex2ScaleT

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex2ScaleT

getset

        {
            get => _indMtx.SS0val.T_Scale1;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS0val.T_Scale1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex3ScaleS

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex3ScaleS

getset

        {
            get => _indMtx.SS1val.S_Scale0;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS1val.S_Scale0 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex3ScaleT

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex3ScaleT

getset

        {
            get => _indMtx.SS1val.T_Scale0;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS1val.T_Scale0 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex4ScaleS

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex4ScaleS

getset

        {
            get => _indMtx.SS1val.S_Scale1;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS1val.S_Scale1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IndirectTex4ScaleT

IndTexScale BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IndirectTex4ScaleT

getset

        {
            get => _indMtx.SS1val.T_Scale1;
            set
            {
                if (!CheckIfMetal())
                {
                    _indMtx.SS1val.T_Scale1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ IsMetal

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.IsMetal

get

◆ LightChannel0

LightChannel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.LightChannel0

get

◆ LightChannel1

LightChannel BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.LightChannel1

get

◆ LightSetIndex

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.LightSetIndex

getset

        {
            get => _lightSetIndex;
            set
            {
                if (!CheckIfMetal())
                {
                    _lightSetIndex = value;
 
                    MetalMaterial?.UpdateAsMetal();
 
                    SignalPropertyChange();
                }
            }
        }

◆ Logic

AlphaOp BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Logic

getset

        {
            get => _alphaFunc.Logic;
            set
            {
                if (!CheckIfMetal())
                {
                    _alphaFunc.Logic = value;
                    SignalPropertyChange();
                }
            }
        }

◆ MetalMaterial

MDL0MaterialNode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.MetalMaterial

get

        {
            get
            {
                foreach (MDL0MaterialNode t in Model._matList)
                {
                    if (!IsMetal)
                    {
                        if (t.Name.StartsWith(Name) && t.IsMetal && Name.Length + 7 == t.Name.Length)
                        {
                            return t;
                        }
                    }
                    else if (Name.StartsWith(t.Name) && !t.IsMetal && t.Name.Length + 7 == Name.Length)
                    {
                        return t;
                    }
                }
 
                return null;
            }
        }

◆ NormMapRefLight1

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.NormMapRefLight1

getset

        {
            get => _normMapRefLight1;
            set
            {
                if (!CheckIfMetal())
                {
                    _normMapRefLight1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ NormMapRefLight2

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.NormMapRefLight2

getset

        {
            get => _normMapRefLight2;
            set
            {
                if (!CheckIfMetal())
                {
                    _normMapRefLight1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ NormMapRefLight3

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.NormMapRefLight3

getset

        {
            get => _normMapRefLight3;
            set
            {
                if (!CheckIfMetal())
                {
                    _normMapRefLight1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ NormMapRefLight4

sbyte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.NormMapRefLight4

getset

        {
            get => _normMapRefLight4;
            set
            {
                if (!CheckIfMetal())
                {
                    _normMapRefLight1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ Objects

MDL0ObjectNode [] BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Objects

get

        {
            get
            {
                if (!IsMetal)
                {
                    return _objects.ToArray();
                }
 
                return MetalMaterial == null ? null : MetalMaterial._objects.ToArray();
            }
        }

◆ Ref0

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Ref0

getset

        {
            get => _alphaFunc._ref0;
            set
            {
                if (!CheckIfMetal())
                {
                    _alphaFunc._ref0 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ Ref1

byte BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Ref1

getset

        {
            get => _alphaFunc._ref1;
            set
            {
                if (!CheckIfMetal())
                {
                    _alphaFunc._ref1 = value;
                    SignalPropertyChange();
                }
            }
        }

◆ ResourceFileType

override ResourceType BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ResourceFileType

get

◆ Shader

string BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Shader

getset

        {
            get => _shader == null ? null : _shader.Name;
            set
            {
                if (CheckIfMetal())
                {
                    return;
                }
 
                if (string.IsNullOrEmpty(value))
                {
                    ShaderNode = null;
                }
                else
                {
                    MDL0ShaderNode node = Model.FindChild($"Shaders/{value}", false) as MDL0ShaderNode;
                    if (node != null)
                    {
                        ShaderNode = node;
                    }
                }
 
                SignalPropertyChange();
            }
        }

◆ ShaderNode

MDL0ShaderNode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.ShaderNode

getset

        {
            get => _shader;
            set
            {
                if (_shader == value)
                {
                    return;
                }
 
                _shader?._materials.Remove(this);
 
                if ((_shader = value) != null)
                {
                    _shader._materials.Add(this);
                    ActiveShaderStages = _shader.Stages;
                }
            }
        }

◆ SrcFactor

BlendFactor BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.SrcFactor

getset

        {
            get => _blendMode.SrcFactor;
            set
            {
                if (!CheckIfMetal())
                {
                    _blendMode.SrcFactor = value;
                    SignalPropertyChange();
                }
            }
        }

◆ Subtract

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.Subtract

getset

        {
            get => _blendMode.Subtract;
            set
            {
                if (!CheckIfMetal())
                {
                    _blendMode.Subtract = value;
                    SignalPropertyChange();
                }
            }
        }

◆ TextureMatrixMode

TexMatrixMode BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.TextureMatrixMode

getset

        {
            get => (TexMatrixMode) _texMtxFlags;
            set
            {
                if (!CheckIfMetal())
                {
                    _texMtxFlags = (uint) value;
                    foreach (MDL0MaterialRefNode r in Children)
                    {
                        r._bindState.MatrixMode = r._frameState.MatrixMode = value;
                    }
 
                    SignalPropertyChange();
                }
            }
        }

◆ UserEntries

UserDataCollection BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.UserEntries

getset

        {
            get => _userEntries;
            set
            {
                _userEntries = value;
                SignalPropertyChange();
            }
        }

◆ XLUMaterial

bool BrawlLib.SSBB.ResourceNodes.MDL0MaterialNode.XLUMaterial

getset

        {
            get => _usageFlags[31];
            set
            {
                if (!CheckIfMetal())
                {
                    //Forget all these checks.
                    //We'll let the user have complete freedom, as I've seen objects use materials
                    //as XLU when this bool wasn't on anyway.
 
                    //bool prev = _usageFlags[31];
                    _usageFlags[31] = value;
 
                    //string message = "";
                    //for (int i = 0; i < _objects.Count; i++)
                    //    _objects[i].EvalMaterials(ref message);
 
                    //if (message.Length != 0)
                    //    if (MessageBox.Show(null, "Are you sure you want to continue?\nThe following objects will no longer use this material:\n" + message, "Continue?", MessageBoxButtons.YesNo) == DialogResult.No)
                    //    {
                    //        _changed = false;
                    //        _usageFlags[31] = prev;
                    //        return;
                    //    }
 
                    //message = "";
                    //for (int i = 0; i < _objects.Count; i++)
                    //    _objects[i].FixMaterials(ref message);
 
                    //if (message.Length != 0)
                    //    MessageBox.Show("The following objects no longer use this material:\n" + message);
 
                    SignalPropertyChange();
                }
            }
        }

The documentation for this class was generated from the following file:

BrawlLib/SSBB/ResourceNodes/MDL0/MDL0MaterialNode.cs

Public Types

Public Member Functions

Public Attributes

Properties

Additional Inherited Members

Member Enumeration Documentation

◆ IndirectMethod

Constructor & Destructor Documentation

◆ MDL0MaterialNode()

Member Function Documentation

◆ ApplyViewportLighting()

◆ CheckIfMetal()

◆ Export()

◆ GenerateShadowMaterial()

◆ GenerateSpyMaterial()

◆ GetImage()

◆ OnCalculateSize()

◆ OnInitialize()

◆ OnPopulate()

◆ OnRebuild()

◆ Remove() [1/2]

◆ Remove() [2/2]

◆ Replace()

◆ SignalPropertyChange()

◆ UpdateAsMetal()

◆ UseProgram()

Member Data Documentation

◆ _activeIndStages

◆ _activeStages

◆ _alphaFunc

◆ _ambientLight

◆ _blendMode

◆ _chan1

◆ _chan2

◆ _constantAlpha

◆ _cull

◆ _depthTestBeforeTexture

◆ _fog

◆ _fogIndex

◆ _fragShaderHandle

◆ _fragShaderSource

◆ _indirectFrameStates

◆ _indirectMethod1

◆ _indirectMethod2

◆ _indirectMethod3

◆ _indirectMethod4

◆ _indMtx

◆ _internalForceRemake

◆ _lights

◆ _lightSetIndex

◆ _normMapRefLight1

◆ _normMapRefLight2

◆ _normMapRefLight3

◆ _normMapRefLight4

◆ _objects

◆ _programHandle

◆ _scn0Applied

◆ _tevColorBlock

◆ _tevKonstBlock

◆ _texMtxFlags

◆ _updating

◆ _vertexShaderHandle

◆ _vertexShaderSource

◆ _zMode

◆ amb1

◆ amb2

◆ c1

◆ c2

◆ c3

◆ clr1

◆ clr2

◆ k1

◆ k2

◆ k3

◆ k4

◆ XFCmds

Property Documentation

◆ ActiveShaderStages

◆ AllowDuplicateNames

◆ BlendLogicOp