BrawlCrate.NodeWrappers.MDL0Wrapper Class Reference

Inheritance diagram for BrawlCrate.NodeWrappers.MDL0Wrapper:

Public Member Functions
	MDL0Wrapper ()
void	ReimportMeshes ()
void	Preview ()
MDL0ShaderNode	NewShader ()
MDL0MaterialNode	NewMaterial ()
void	AutoMetal ()
void	NameMaterial ()
void	NameObject ()
void	NameVertex ()
void	NameNormal ()
void	NameColor ()
void	NameUV ()
MDL0VertexNode	NewVertex ()
MDL0NormalNode	NewNormal ()
MDL0ColorNode	NewColor ()
MDL0UVNode	NewUV ()
void	ImportMaterial ()
void	ImportShader ()
void	ImportVertex ()
void	ImportNormal ()
void	ImportColor ()
void	ImportUV ()
void	ImportObject ()
void	SortMaterial ()
void	SortVertex ()
void	SortNormal ()
void	SortColor ()
void	SortUV ()
void	SortObject ()
void	SortTexture ()
void	ShadowConvert ()
void	SpyConvert ()
void	InvertMaterials ()
void	CullMaterials (CullMode mode)
Public Member Functions inherited from BrawlCrate.NodeWrappers.GenericWrapper
	GenericWrapper (IWin32Window owner)
	GenericWrapper ()
virtual void	Sort ()
void	MoveUp ()
virtual void	MoveUp (bool select)
void	MoveDown ()
virtual void	MoveDown (bool select)
void	DeleteSelected ()
void	ExportSelected ()
virtual string	Export ()
virtual void	OnExport (string outPath)
virtual void	Replace ()
virtual void	OnReplace (string inStream)
void	Restore ()
virtual void	Delete ()
void	Rename ()
virtual ResourceNode	Duplicate ()
virtual ResourceNode	Duplicate (bool changeName)
Public Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
void	Link (ResourceNode res)
void	Unlink ()

Static Protected Member Functions
static void	PreviewAction (object sender, EventArgs e)
static void	ImportObjectAction (object sender, EventArgs e)
static void	RecalcBBsOption (object sender, EventArgs e)
static void	MetalAction (object sender, EventArgs e)
static void	NewShaderAction (object sender, EventArgs e)
static void	NewMaterialAction (object sender, EventArgs e)
static void	NewVertexAction (object sender, EventArgs e)
static void	NewNormalAction (object sender, EventArgs e)
static void	NewColorAction (object sender, EventArgs e)
static void	NewUVAction (object sender, EventArgs e)
static void	NameMaterialAction (object sender, EventArgs e)
static void	NameVertexAction (object sender, EventArgs e)
static void	NameNormalAction (object sender, EventArgs e)
static void	NameColorAction (object sender, EventArgs e)
static void	NameUVAction (object sender, EventArgs e)
static void	NameObjectAction (object sender, EventArgs e)
static void	ImportVertexAction (object sender, EventArgs e)
static void	ImportNormalAction (object sender, EventArgs e)
static void	ImportColorAction (object sender, EventArgs e)
static void	ImportUVAction (object sender, EventArgs e)
static void	ImportMaterialAction (object sender, EventArgs e)
static void	ImportShaderAction (object sender, EventArgs e)
static void	SortMaterialAction (object sender, EventArgs e)
static void	SortVertexAction (object sender, EventArgs e)
static void	SortNormalAction (object sender, EventArgs e)
static void	SortColorAction (object sender, EventArgs e)
static void	SortUVAction (object sender, EventArgs e)
static void	SortObjectAction (object sender, EventArgs e)
static void	SortTextureAction (object sender, EventArgs e)
static void	InvertMaterialsAction (object sender, EventArgs e)
static void	CullNoneAction (object sender, EventArgs e)
static void	CullOutsideAction (object sender, EventArgs e)
static void	CullInsideAction (object sender, EventArgs e)
static void	CullAllAction (object sender, EventArgs e)
static void	ShadowConvertAction (object sender, EventArgs e)
static void	SpyConvertAction (object sender, EventArgs e)
static void	StripAction (object sender, EventArgs e)
Static Protected Member Functions inherited from BrawlCrate.NodeWrappers.GenericWrapper
static void	MoveUpAction (object sender, EventArgs e)
static void	MoveDownAction (object sender, EventArgs e)
static void	ExportAction (object sender, EventArgs e)
static void	ExportSelectedAction (object sender, EventArgs e)
static void	DeleteSelectedAction (object sender, EventArgs e)
static void	DuplicateAction (object sender, EventArgs e)
static void	ReplaceAction (object sender, EventArgs e)
static void	RestoreAction (object sender, EventArgs e)
static void	DeleteAction (object sender, EventArgs e)
static void	RenameAction (object sender, EventArgs e)
static void	SortAction (object sender, EventArgs e)
Static Protected Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
static T	GetInstance< T > ()
static IEnumerable< T >	GetInstances< T > ()

Properties
override string	ExportFilter [get]
override string	ImportFilter [get]
Properties inherited from BrawlCrate.NodeWrappers.GenericWrapper
virtual ContextMenuStrip	MultiSelectMenuStrip [get]
virtual string	DefaultName [get]
virtual string	ExportFilter [get]
virtual string	ImportFilter [get]
virtual string	ReplaceFilter [get]
Properties inherited from BrawlCrate.NodeWrappers.BaseWrapper
ResourceNode	Resource [get]
virtual ? Color	DefaultBackColor [get]
virtual ? Color	DefaultForeColor [get]
Properties inherited from BrawlCrate.NodeWrappers.MultiSelectableWrapper
ContextMenuStrip	MultiSelectMenuStrip [get]

Additional Inherited Members
Static Public Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
static BaseWrapper[]	GetAllNodes (BaseWrapper root)
static BaseWrapper	Wrap (ResourceNode node)
static BaseWrapper	Wrap (IWin32Window owner, ResourceNode node)
Static Public Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
static IWin32Window	_owner
Protected Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
	BaseWrapper ()
Protected Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
bool	_discovered
ResourceNode	_resource
Static Protected Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
static readonly ContextMenuStrip	_emptyMenu = new ContextMenuStrip()

Constructor & Destructor Documentation

MDL0Wrapper()

BrawlCrate.NodeWrappers.MDL0Wrapper.MDL0Wrapper ( )

inline

        {
            ContextMenuStrip = _menu;
        }

Member Function Documentation

AutoMetal()

void BrawlCrate.NodeWrappers.MDL0Wrapper.AutoMetal ( )

inline

        {
            if (MessageBox.Show(null,
                "Are you sure you want to (re)generate metal materials for Brawl?\nAll existing metal materials and shaders will be reset.",
                "", MessageBoxButtons.YesNo) == DialogResult.Yes)
            {
                ((MDL0Node) _resource).GenerateMetalMaterials();
            }
        }

CullAllAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.CullAllAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().CullMaterials(CullMode.Cull_All);
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

CullInsideAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.CullInsideAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().CullMaterials(CullMode.Cull_Inside);
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

CullMaterials()

void BrawlCrate.NodeWrappers.MDL0Wrapper.CullMaterials ( CullMode  mode )

inline

        {
            if (_resource is MDL0Node mdl)
            {
                if (mdl.MaterialList == null)
                {
                    return;
                }
 
                foreach (MDL0MaterialNode mat in mdl.MaterialList)
                {
                    mat.CullMode = mode;
                }
            }
        }

CullNoneAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.CullNoneAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().CullMaterials(CullMode.Cull_None);
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

CullOutsideAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.CullOutsideAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().CullMaterials(CullMode.Cull_Outside);
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

ImportColor()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportColor ( )

inline

        {
            if (Program.OpenFiles("Raw Color Set (*.*)|*.*", out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewColor().Replace(path);
                }
            }
        }

ImportColorAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportColorAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportColor();
        }

ImportMaterial()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportMaterial ( )

inline

        {
            if (Program.OpenFiles(FileFilters.MDL0Material, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    MDL0MaterialNode m = NewMaterial();
                    m.Name = Path.GetFileNameWithoutExtension(path);
                    m.Replace(path);
                }
            }
        }

ImportMaterialAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportMaterialAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportMaterial();
        }

ImportNormal()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportNormal ( )

inline

        {
            if (Program.OpenFiles("Raw Normal Set (*.*)|*.*", out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewNormal().Replace(path);
                }
            }
        }

ImportNormalAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportNormalAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportNormal();
        }

ImportObject()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportObject ( )

inline

        {
            if (Program.OpenFiles(ImportFilter, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    MDL0Node external;
                    if ((external = MDL0Node.FromFile(path)) != null)
                    {
                        new ObjectImporter().ShowDialog((MDL0Node) _resource, external);
                    }
                    else
                    {
                        MessageBox.Show($"Could not import an object from {path}", "Error", MessageBoxButtons.OK,
                            MessageBoxIcon.Error);
                    }
                }
            }
        }

ImportObjectAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportObjectAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportObject();
        }

ImportShader()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportShader ( )

inline

        {
            if (Program.OpenFiles(FileFilters.MDL0Shader, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewShader()?.Replace(path);
                }
            }
        }

ImportShaderAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportShaderAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportShader();
        }

ImportUV()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportUV ( )

inline

        {
            if (Program.OpenFiles("Raw UV Set (*.*)|*.*", out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewUV().Replace(path);
                }
            }
        }

ImportUVAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportUVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportUV();
        }

ImportVertex()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportVertex ( )

inline

        {
            if (Program.OpenFiles("Raw Vertex Set (*.*)|*.*", out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewVertex().Replace(path);
                }
            }
        }

ImportVertexAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ImportVertexAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ImportVertex();
        }

InvertMaterials()

void BrawlCrate.NodeWrappers.MDL0Wrapper.InvertMaterials ( )

inline

        {
            if (_resource is MDL0Node mdl)
            {
                if (mdl.MaterialList == null)
                {
                    return;
                }
 
                foreach (MDL0MaterialNode mat in mdl.MaterialList)
                {
                    if (mat.CullMode == CullMode.Cull_Inside)
                    {
                        mat.CullMode = CullMode.Cull_Outside;
                    }
                    else if (mat.CullMode == CullMode.Cull_Outside)
                    {
                        mat.CullMode = CullMode.Cull_Inside;
                    }
                }
            }
        }

InvertMaterialsAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.InvertMaterialsAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().InvertMaterials();
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

MetalAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.MetalAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().AutoMetal();
        }

NameColor()

void BrawlCrate.NodeWrappers.MDL0Wrapper.NameColor ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
            MDL0GroupNode g = model._colorGroup;
            if (g != null)
            {
                foreach (MDL0ColorNode v in g.Children)
                {
                    string name = model.Name + "_";
                    if (v._objects.Count > 0)
                    {
                        MDL0ObjectNode o = v._objects[0];
                        name += o.Name;
                        if (o._drawCalls.Count > 0)
                        {
                            DrawCall c = o._drawCalls[0];
                            if (c.MaterialNode != null && c.VisibilityBoneNode != null)
                            {
                                name += "_" + c.Material + "_" + c.VisibilityBone;
                            }
                        }
                    }
                    else
                    {
                        name += "ColorArray";
                    }
 
                    v.Name = g.FindName(name);
                }
            }
        }

NameColorAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NameColorAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NameColor();
        }

NameMaterial()

void BrawlCrate.NodeWrappers.MDL0Wrapper.NameMaterial ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
            MDL0GroupNode g = model._matGroup;
            int i = 0;
            if (g != null)
            {
                foreach (MDL0MaterialNode m in g.Children)
                {
                    m.Name = "Material_" + i++;
                }
            }
        }

NameMaterialAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NameMaterialAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NameMaterial();
        }

NameNormal()

void BrawlCrate.NodeWrappers.MDL0Wrapper.NameNormal ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
            MDL0GroupNode g = model._normGroup;
            if (g != null)
            {
                foreach (MDL0NormalNode v in g.Children)
                {
                    string name = model.Name + "_";
                    if (v._objects.Count > 0)
                    {
                        MDL0ObjectNode o = v._objects[0];
                        name += o.Name;
                        if (o._drawCalls.Count > 0)
                        {
                            DrawCall c = o._drawCalls[0];
                            if (c.MaterialNode != null && c.VisibilityBoneNode != null)
                            {
                                name += "_" + c.Material + "_" + c.VisibilityBone;
                            }
                        }
                    }
                    else
                    {
                        name += "NormalArray";
                    }
 
                    v.Name = g.FindName(name);
                }
            }
        }

NameNormalAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NameNormalAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NameNormal();
        }

NameObject()

void BrawlCrate.NodeWrappers.MDL0Wrapper.NameObject ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
            MDL0GroupNode g = model._objGroup;
            int i = 0;
            if (g != null)
            {
                foreach (MDL0ObjectNode o in g.Children)
                {
                    o.Name = "polygon" + i++;
                }
            }
        }

NameObjectAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NameObjectAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NameObject();
        }

NameUV()

void BrawlCrate.NodeWrappers.MDL0Wrapper.NameUV ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
            MDL0GroupNode g = model._uvGroup;
            int i = 0;
            if (g != null)
            {
                foreach (MDL0UVNode v in g.Children)
                {
                    v.Name = "#" + i++;
                }
            }
        }

NameUVAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NameUVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NameUV();
        }

NameVertex()

void BrawlCrate.NodeWrappers.MDL0Wrapper.NameVertex ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
            MDL0GroupNode g = model._vertGroup;
            if (g != null)
            {
                foreach (MDL0VertexNode v in g.Children)
                {
                    string name = model.Name + "_";
                    if (v._objects.Count > 0)
                    {
                        MDL0ObjectNode o = v._objects[0];
                        name += o.Name;
                        if (o._drawCalls.Count > 0)
                        {
                            DrawCall c = o._drawCalls[0];
                            if (c.MaterialNode != null && c.VisibilityBoneNode != null)
                            {
                                name += "_" + c.Material + "_" + c.VisibilityBone;
                            }
                        }
                    }
                    else
                    {
                        name += "VertexArray";
                    }
 
                    v.Name = g.FindName(name);
                }
            }
        }

NameVertexAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NameVertexAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NameVertex();
        }

NewColor()

MDL0ColorNode BrawlCrate.NodeWrappers.MDL0Wrapper.NewColor ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
 
            MDL0GroupNode g = model._colorGroup;
            if (g == null)
            {
                model.AddChild(g = new MDL0GroupNode(MDLResourceType.Colors), true);
                model._colorGroup = g;
                model._colorList = g.Children;
            }
 
            MDL0ColorNode node = new MDL0ColorNode {Name = "ColorSet" + ((MDL0Node) _resource)._colorList.Count};
            node.Colors = new RGBAPixel[] {new RGBAPixel {A = 255, R = 128, G = 128, B = 128}};
            g.AddChild(node, true);
 
            node.Rebuild(true);
            node.SignalPropertyChange();
 
            FindResource(node, true).EnsureVisible();
 
            return node;
        }

NewColorAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NewColorAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NewColor();
        }

NewMaterial()

MDL0MaterialNode BrawlCrate.NodeWrappers.MDL0Wrapper.NewMaterial ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
 
            if (model._matGroup == null)
            {
                MDL0GroupNode g = model._matGroup;
                if (g == null)
                {
                    model.AddChild(g = new MDL0GroupNode(MDLResourceType.Materials), true);
                    model._matGroup = g;
                    model._matList = g.Children;
                }
            }
 
            MDL0MaterialNode mat = new MDL0MaterialNode();
            model._matGroup.AddChild(mat);
            mat.Name = "Material" + mat.Index;
 
            if (model._shadGroup == null)
            {
                MDL0GroupNode g = model._shadGroup;
                if (g == null)
                {
                    model.AddChild(g = new MDL0GroupNode(MDLResourceType.Shaders), true);
                    model._shadGroup = g;
                    model._shadList = g.Children;
                }
            }
 
            if (model._shadList.Count == 0)
            {
                NewShader();
            }
 
            mat.ShaderNode = (MDL0ShaderNode) model._shadList[0];
            MDL0MaterialRefNode mr = new MDL0MaterialRefNode();
            mat.AddChild(mr);
            mr.Name = "MatRef0";
            mat.Rebuild(true);
 
            BaseWrapper b = FindResource(mat, true);
            b?.EnsureVisible();
 
            return mat;
        }

NewMaterialAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NewMaterialAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NewMaterial();
        }

NewNormal()

MDL0NormalNode BrawlCrate.NodeWrappers.MDL0Wrapper.NewNormal ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
 
            MDL0GroupNode g = model._normGroup;
            if (g == null)
            {
                model.AddChild(g = new MDL0GroupNode(MDLResourceType.Normals), true);
                model._normGroup = g;
                model._normList = g.Children;
            }
 
            MDL0NormalNode node = new MDL0NormalNode {Name = "NormalSet" + ((MDL0Node) _resource)._normList.Count};
            node.Normals = new Vector3[] {new Vector3(0)};
            g.AddChild(node, true);
            node._forceRebuild = true;
            node.Rebuild(true);
            node.SignalPropertyChange();
 
            FindResource(node, true).EnsureVisible();
 
            return node;
        }

NewNormalAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NewNormalAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NewNormal();
        }

NewShader()

MDL0ShaderNode BrawlCrate.NodeWrappers.MDL0Wrapper.NewShader ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
 
            if (model._shadGroup == null)
            {
                MDL0GroupNode g = model._shadGroup;
                if (g == null)
                {
                    model.AddChild(g = new MDL0GroupNode(MDLResourceType.Shaders), true);
                    model._shadGroup = g;
                    model._shadList = g.Children;
                }
            }
 
            if (model._shadList != null &&
                model._matList != null &&
                model._shadList.Count < model._matList.Count)
            {
                MDL0ShaderNode shader = new MDL0ShaderNode();
                model._shadGroup.AddChild(shader);
                shader.Default();
                shader.Rebuild(true);
 
                BaseWrapper b = FindResource(shader, true);
                b?.EnsureVisible();
 
                return shader;
            }
 
            MessageBox.Show("Shader could not be added. Make sure that you do not have more shaders than materials",
                "Error");
            return null;
        }

NewShaderAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NewShaderAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NewShader();
        }

NewUV()

MDL0UVNode BrawlCrate.NodeWrappers.MDL0Wrapper.NewUV ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
 
            MDL0GroupNode g = model._uvGroup;
            if (g == null)
            {
                model.AddChild(g = new MDL0GroupNode(MDLResourceType.UVs), true);
                model._uvGroup = g;
                model._uvList = g.Children;
            }
 
            MDL0UVNode node = new MDL0UVNode {Name = "#" + ((MDL0Node) _resource)._uvList.Count};
            node.Points = new Vector2[] {new Vector2(0)};
            g.AddChild(node, true);
            node._forceRebuild = true;
            node.Rebuild(true);
            node.SignalPropertyChange();
 
            FindResource(node, true).EnsureVisible();
 
            return node;
        }

NewUVAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NewUVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NewUV();
        }

NewVertex()

MDL0VertexNode BrawlCrate.NodeWrappers.MDL0Wrapper.NewVertex ( )

inline

        {
            MDL0Node model = (MDL0Node) _resource;
 
            MDL0GroupNode g = model._vertGroup;
            if (g == null)
            {
                model.AddChild(g = new MDL0GroupNode(MDLResourceType.Vertices), true);
                model._vertGroup = g;
                model._vertList = g.Children;
            }
 
            MDL0VertexNode node = new MDL0VertexNode {Name = "VertexSet" + ((MDL0Node) _resource)._vertList.Count};
            node.Vertices = new Vector3[] {new Vector3(0)};
            g.AddChild(node, true);
            node.ForceRebuild = true;
            node.Rebuild(true);
            node.SignalPropertyChange();
 
            FindResource(node, true).EnsureVisible();
 
            return node;
        }

NewVertexAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.NewVertexAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().NewVertex();
        }

Preview()

void BrawlCrate.NodeWrappers.MDL0Wrapper.Preview ( )

inline

        {
            new ModelForm().Show(_owner, (MDL0Node) _resource);
        }

PreviewAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.PreviewAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().Preview();
        }

RecalcBBsOption()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.RecalcBBsOption ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().RecalcBoundingBoxes();
        }

ReimportMeshes()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ReimportMeshes ( )

inline

        {
            OpenFileDialog ofd = new OpenFileDialog
            {
                Filter = ImportFilter,
                Title = "Please select a model to reimport meshes from."
            };
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                MDL0Node replacement = MDL0Node.FromFile(ofd.FileName);
                if (replacement != null)
                {
                    ((MDL0Node) _resource).ReplaceMeshes(replacement, true, true, true);
                    replacement.Dispose();
                    _resource.UpdateCurrentControl();
                }
            }
        }

ShadowConvert()

void BrawlCrate.NodeWrappers.MDL0Wrapper.ShadowConvert ( )

inline

        {
            ((MDL0Node) _resource).ConvertToShadowModel();
        }

ShadowConvertAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.ShadowConvertAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().ShadowConvert();
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

SortColor()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortColor ( )

inline

        {
            ((MDL0Node) _resource).ColorGroup.SortChildren();
            RefreshView(_resource);
        }

SortColorAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortColorAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortColor();
        }

SortMaterial()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortMaterial ( )

inline

        {
            ((MDL0Node) _resource).MaterialGroup.SortChildren();
            RefreshView(_resource);
        }

SortMaterialAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortMaterialAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortMaterial();
        }

SortNormal()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortNormal ( )

inline

        {
            ((MDL0Node) _resource).NormalGroup.SortChildren();
            RefreshView(_resource);
        }

SortNormalAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortNormalAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortNormal();
        }

SortObject()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortObject ( )

inline

        {
            ((MDL0Node) _resource).PolygonGroup.SortChildren();
            RefreshView(_resource);
        }

SortObjectAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortObjectAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortObject();
        }

SortTexture()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortTexture ( )

inline

        {
            ((MDL0Node) _resource).TextureGroup.SortChildren();
            RefreshView(_resource);
        }

SortTextureAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortTextureAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortTexture();
        }

SortUV()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortUV ( )

inline

        {
            ((MDL0Node) _resource).UVGroup.SortChildren();
            RefreshView(_resource);
        }

SortUVAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortUVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortUV();
        }

SortVertex()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SortVertex ( )

inline

        {
            ((MDL0Node) _resource).VertexGroup.SortChildren();
            RefreshView(_resource);
        }

SortVertexAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SortVertexAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SortVertex();
        }

SpyConvert()

void BrawlCrate.NodeWrappers.MDL0Wrapper.SpyConvert ( )

inline

        {
            ((MDL0Node) _resource).ConvertToSpyModel();
        }

SpyConvertAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.SpyConvertAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().SpyConvert();
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

StripAction()

static void BrawlCrate.NodeWrappers.MDL0Wrapper.StripAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDL0Wrapper>().StripModel();
            MainForm.Instance.resourceTree_SelectionChanged(sender, e);
        }

Property Documentation

ExportFilter

override string BrawlCrate.NodeWrappers.MDL0Wrapper.ExportFilter

get

ImportFilter

override string BrawlCrate.NodeWrappers.MDL0Wrapper.ImportFilter

get

---

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

• BrawlCrate/NodeWrappers/MDL0/MDL0Wrapper.cs