BrawlLib.Modeling.PrimitiveManager Class Reference

Inheritance diagram for BrawlLib.Modeling.PrimitiveManager:

Public Member Functions
void	SetAssetChanged (int index)
PrimitiveManager	HardCopy ()
	Returns an identical copy of this manager but as a completely new instance with reallocated buffers. More...
Vector3[]	GetVertices (bool force)
	Returns vertex positions from each vertex. More...
Vector3[]	GetNormals (bool force)
	Retrieves normals from raw facedata in a remapped array. More...
Vector2[]	GetUVs (int index, bool force)
	Retrieves texture coordinates from raw facedata in a remapped array. More...
RGBAPixel[]	GetColors (int index, bool force)
	Retrieves color values from raw facedata in a remapped array. More...
	PrimitiveManager ()
	PrimitiveManager (MDL0Object *polygon, AssetStorage assets, IMatrixNode[] nodes, IObject owner)
void	Dispose ()
int	GetDisplayListSize ()
void	GroupPrimitives (bool useStrips, uint cacheSize, uint minStripLen, bool pushCacheHits, bool forceCCW, out int newPointCount, out int newFaceCount)
	Currently should only should be called when importing a model with the collada importer or when internal asset data has changed and needs to be distributed to external arrays More...
void	SetVertexDescList (short[] indices, List< VertexCodec > vertexCodecs, List< ColorCodec > colorCodecs, params bool[] forceDirect)
void	WriteVertexDescriptor (out CPVertexFormat vertexFormat, out XFVertexSpecs vertexSpecs)
	This sets up how to read the facepoints that are going to be written. More...
void	SetFormatList (MDL0ObjectNode polygon, ModelLinker linker)
void	WriteVertexFormat (MDL0Object *polygon)
uint	ShiftVtxLo (uint pmidx, uint t76543210midx, uint pos, uint nrm, uint col0, uint col1)
uint	ShiftVtxHi (uint tex0, uint tex1, uint tex2, uint tex3, uint tex4, uint tex5, uint tex6, uint tex7)
uint	ShiftXFSpecs (uint host_colors, uint host_normal, uint host_textures)
uint	ShiftUVATA (uint posCnt, uint posFmt, uint posShft, uint nrmCnt, uint nrmFmt, uint Col0Cnt, uint Col0Fmt, uint Col1Cnt, uint Col1Fmt, uint tex0Cnt, uint tex0Fmt, uint tex0Shft, uint normalIndex3)
uint	ShiftUVATB (uint tex1Cnt, uint tex1Fmt, uint tex1Shft, uint tex2Cnt, uint tex2Fmt, uint tex2Shft, uint tex3Cnt, uint tex3Fmt, uint tex3Shft, uint tex4Cnt, uint tex4Fmt)
uint	ShiftUVATC (uint tex4Shft, uint tex5Cnt, uint tex5Fmt, uint tex5Shft, uint tex6Cnt, uint tex6Fmt, uint tex6Shft, uint tex7Cnt, uint tex7Fmt, uint tex7Shft)
void	Unweight (bool updateAssets)
void	Weight ()
void	PrepareStream ()
void	BindStream ()
void	DisableTextures ()
void	ApplyTexture (TexSourceRow source)
void	RenderMesh ()
void	PositionsChanged (MDL0ObjectNode obj, bool forceNewNode=false)
void	NormalsChanged (MDL0ObjectNode obj, bool forceNewNode=false)
void	ColorsChanged (MDL0ObjectNode obj, int id, bool forceNewNode=false)
void	UVsChanged (MDL0ObjectNode obj, int id, bool forceNewNode=false)

Public Attributes
List< Vertex3 >	_vertices
UnsafeBuffer	_indices
int	_pointCount
int	_faceCount
int	_renderStride
UnsafeBuffer[]	_faceData = new UnsafeBuffer[12]
bool[]	_dirty = new bool[12]
UnsafeBuffer	_graphicsBuffer
bool[]	HasTextureMatrix = new bool[8]
bool[]	UseIdentityTexMtx = new bool[8]
bool	_remakePrimitives
bool	_isWeighted
int	_primitiveSize
List< FacepointAttribute >	_descList
List< VertexAttributeFormat >	_fmtList
XFArrayFlags	_arrayFlags
int	_fpStride
List< PrimitiveGroup >	_primGroups = new List<PrimitiveGroup>()
int	_arrayHandle
int	_arrayBufferHandle
int	_elementArrayBufferHandle
bool	_render = true
bool	_renderNormals = true

Static Public Attributes
static Color	DefaultVertColor = Color.FromArgb(0, 128, 0)
static Color	DefaultNormColor = Color.FromArgb(0, 0, 128)
static float	NormalLength = 0.5f
const float	_nodeRadius = 0.05f

Properties
bool	AssetsChanged [get, set]
bool	HasTexMtx [get]

Constructor & Destructor Documentation

PrimitiveManager() [1/2]

BrawlLib.Modeling.PrimitiveManager.PrimitiveManager ( )

inline

        {
        }

PrimitiveManager() [2/2]

BrawlLib.Modeling.PrimitiveManager.PrimitiveManager ( MDL0Object *  polygon, AssetStorage  assets, IMatrixNode[]  nodes, IObject  owner  )

inline

        {
            _owner = owner;
 
            byte*[] pAssetList = new byte*[12];
            byte*[] pFaceBuffers = new byte*[12];
            int id;
 
            //This relies on the header being accurate!
            _indices = new UnsafeBuffer(2 * (_pointCount = polygon->_numVertices));
            _faceCount = polygon->_numFaces;
 
            _arrayFlags = polygon->_arrayFlags;
            for (int i = 0; i < 8; i++)
            {
                HasTextureMatrix[i] = _arrayFlags.GetHasTexMatrix(i);
            }
 
            //Compile decode script by reading the polygon def list
            //This sets how to read the facepoints
            ElementDescriptor desc = new ElementDescriptor();
            desc.SetupMDL0(polygon);
 
            //Grab asset lists in sequential order.
            if ((id = polygon->_vertexId) >= 0 && desc.HasData[0] && assets.Assets[0] != null)
            {
                pFaceBuffers[0] = (byte*) (_faceData[0] = new UnsafeBuffer(12 * _pointCount)).Address;
                pAssetList[0] = (byte*) assets.Assets[0][id].Address;
            }
 
            if ((id = polygon->_normalId) >= 0 && desc.HasData[1] && assets.Assets[1] != null)
            {
                pFaceBuffers[1] = (byte*) (_faceData[1] = new UnsafeBuffer(12 * _pointCount)).Address;
                pAssetList[1] = (byte*) assets.Assets[1][id].Address;
            }
 
            for (int i = 0, x = 2; i < 2; i++, x++)
            {
                if ((id = ((bshort*) polygon->_colorIds)[i]) >= 0 && desc.HasData[x] && assets.Assets[2] != null)
                {
                    pFaceBuffers[x] = (byte*) (_faceData[x] = new UnsafeBuffer(4 * _pointCount)).Address;
                    pAssetList[x] = (byte*) assets.Assets[2][id].Address;
                }
            }
 
            for (int i = 0, x = 4; i < 8; i++, x++)
            {
                if ((id = ((bshort*) polygon->_uids)[i]) >= 0 && desc.HasData[x] && assets.Assets[3] != null)
                {
                    pFaceBuffers[x] = (byte*) (_faceData[x] = new UnsafeBuffer(8 * _pointCount)).Address;
                    pAssetList[x] = (byte*) assets.Assets[3][id].Address;
                }
            }
 
            int triCount = 0, lineCount = 0, pointCount = 0;
            byte* pData = (byte*) polygon->PrimitiveData;
 
            fixed (byte** pOut = pFaceBuffers)
            {
                fixed (byte** pAssets = pAssetList)
                {
                    _primGroups = ReadPrimitives(pData, ref desc, pOut, pAssets, nodes, ref triCount, ref lineCount,
                        ref pointCount);
                }
            }
 
            CreateGLPrimitives(triCount, lineCount, pointCount);
 
            uint p3 = 0, p2 = 0, p1 = 0;
            ExtractIndices(pData, desc.Stride, ref p3, ref p2, ref p1);
 
            //Compile merged vertex list
            _vertices = desc.Finish((Vector3*) pAssetList[0], nodes);
 
            ushort* pIndex = (ushort*) _indices.Address;
            for (int x = 0; x < _pointCount; x++, pIndex++)
            {
                if (*pIndex >= 0 && *pIndex < _vertices.Count)
                {
                    _vertices[*pIndex].FaceDataIndices.Add(x);
                }
            }
 
            foreach (Vertex3 v in _vertices)
            {
                v.Parent = _owner as IMatrixNodeUser;
            }
        }

Member Function Documentation

ApplyTexture()

void BrawlLib.Modeling.PrimitiveManager.ApplyTexture ( TexSourceRow  source )

inline

        {
            int texId = source >= TexSourceRow.TexCoord0 ? source - TexSourceRow.TexCoord0 : -1 - (int) source;
            texId = texId < 0 ? 0 : texId;
 
            if (texId >= 0 && _faceData[texId + 4] != null)
            {
                byte* pData = (byte*) _graphicsBuffer.Address;
                for (int i = 0; i < texId + 4; i++)
                {
                    if (_faceData[i] != null)
                    {
                        if (i < 2)
                        {
                            pData += 12;
                        }
                        else if (i < 4)
                        {
                            pData += 4;
                        }
                        else
                        {
                            pData += 8;
                        }
                    }
                }
 
                GL.EnableClientState(ArrayCap.TextureCoordArray);
                GL.TexCoordPointer(2, TexCoordPointerType.Float, _renderStride, (IntPtr) pData);
            }
        }

BindStream()

void BrawlLib.Modeling.PrimitiveManager.BindStream ( )

inline

        {
            byte* pData = (byte*) _graphicsBuffer.Address;
            for (int i = 0; i < 12; i++)
            {
                if (_faceData[i] != null)
                {
                    switch (i)
                    {
                        case 0:
                            GL.EnableClientState(ArrayCap.VertexArray);
                            GL.VertexPointer(3, VertexPointerType.Float, _renderStride, (IntPtr) pData);
                            pData += 12;
                            break;
                        case 1:
                            GL.EnableClientState(ArrayCap.NormalArray);
                            GL.NormalPointer(NormalPointerType.Float, _renderStride, (IntPtr) pData);
                            pData += 12;
                            break;
                        case 2:
                            GL.EnableClientState(ArrayCap.ColorArray);
                            GL.ColorPointer(4, ColorPointerType.UnsignedByte, _renderStride, (IntPtr) pData);
                            pData += 4;
                            break;
                        case 3:
                            GL.EnableClientState(ArrayCap.SecondaryColorArray);
                            GL.SecondaryColorPointer(4, ColorPointerType.UnsignedByte, _renderStride, (IntPtr) pData);
                            pData += 4;
                            break;
                        default:
                            pData += 8;
                            break;
                    }
                }
            }
        }

ColorsChanged()

void BrawlLib.Modeling.PrimitiveManager.ColorsChanged ( MDL0ObjectNode  obj, int  id, bool  forceNewNode = false  )

inline

        {
            id = id.Clamp(0, 1);
 
            if (obj == null || _faceData[id + 2] == null)
            {
                return;
            }
 
            SetAssetChanged(id + 2);
            obj._forceRebuild = true;
            obj.SignalPropertyChange();
 
            MDL0ColorNode node;
            if (obj._colorSet[id] != null)
            {
                if (obj._colorSet[id]._objects.Count == 1 && !forceNewNode)
                {
                    node = obj._colorSet[id];
                }
                else
                {
                    node = new MDL0ColorNode();
                    obj.Model.ColorGroup.AddChild(node);
                    node.Name = node.FindName("Regenerated");
                    if (obj._colorSet[id]._objects.Contains(obj))
                    {
                        obj._colorSet[id]._objects.Remove(obj);
                    }
 
                    obj._colorSet[id] = node;
                    obj._colorSet[id]._objects.Add(obj);
                    obj._elementIndices[id + 2] = (short) obj._colorSet[id].Index;
                }
            }
            else
            {
                node = new MDL0ColorNode();
                MDL0Node m = obj.Model;
                if (m.ColorGroup == null)
                {
                    MDL0GroupNode g = new MDL0GroupNode(MDLResourceType.Colors);
                    m.LinkGroup(g);
                    g.Parent = m;
                }
 
                m.ColorGroup.AddChild(node);
                node.Name = node.FindName("Regenerated");
                obj._colorSet[id] = node;
                obj._colorSet[id]._objects.Add(obj);
                obj._elementIndices[id + 2] = (short) obj._colorSet[id].Index;
            }
 
            node.Colors = GetColors(id, true);
            RGBAPixel* pData = (RGBAPixel*) _faceData[id + 2].Address;
            foreach (Vertex3 v in _vertices)
            {
                for (int i = 0; i < v.FaceDataIndices.Count; i++)
                {
                    v.Facepoints[i]._colorIndices[id] = Array.IndexOf(node.Colors, pData[v.FaceDataIndices[i]]);
                }
            }
        }

DisableTextures()

void BrawlLib.Modeling.PrimitiveManager.DisableTextures ( )

inline

        {
            GL.DisableClientState(ArrayCap.TextureCoordArray);
            GL.Disable(EnableCap.Texture2D);
        }

Dispose()

void BrawlLib.Modeling.PrimitiveManager.Dispose ( )

inline

        {
            if (_graphicsBuffer != null)
            {
                _graphicsBuffer.Dispose();
                _graphicsBuffer = null;
            }
 
            if (_faceData != null)
            {
                for (int i = 0; i < _faceData.Length; i++)
                {
                    if (_faceData[i] != null)
                    {
                        _faceData[i].Dispose();
                        _faceData[i] = null;
                    }
                }
 
                _faceData = null;
            }
 
            if (_indices != null)
            {
                _indices.Dispose();
                _indices = null;
            }
        }

GetColors()

RGBAPixel[] BrawlLib.Modeling.PrimitiveManager.GetColors ( int  index, bool  force  )

inline

Retrieves color values from raw facedata in a remapped array.

Parameters

index	The color set to retrieve. Values 0 - 1
force	If not forced, will return values created by a previous call (if there was one).

Returns

        {
            index = index.Clamp(0, 1);
 
            if (_colors[index] != null && _colors[index].Length != 0 && !force)
            {
                return _colors[index];
            }
 
            HashSet<RGBAPixel> list = new HashSet<RGBAPixel>();
            if (_faceData[index + 2] != null)
            {
                RGBAPixel* pIn = (RGBAPixel*) _faceData[index + 2].Address;
                for (int i = 0; i < _pointCount; i++)
                {
                    list.Add(*pIn++);
                }
            }
 
            _colors[index] = new RGBAPixel[list.Count];
            list.CopyTo(_colors[index]);
 
            return _colors[index];
        }

GetDisplayListSize()

int BrawlLib.Modeling.PrimitiveManager.GetDisplayListSize ( )

inline

        {
            _primitiveSize = 0;
 
            foreach (PrimitiveGroup g in _primGroups)
            {
                if (_remakePrimitives)
                {
                    if (g._tristrips.Count != 0)
                    {
                        foreach (PointTriangleStrip strip in g._tristrips)
                        {
                            _primitiveSize += 3 + strip._points.Count * _fpStride;
                        }
                    }
 
                    if (g._triangles.Count != 0)
                    {
                        _primitiveSize += 3 + g._triangles.Count * 3 * _fpStride;
                    }
 
                    if (g._linestrips.Count != 0)
                    {
                        foreach (PointLineStrip strip in g._linestrips)
                        {
                            _primitiveSize += 3 + strip._points.Count * _fpStride;
                        }
                    }
 
                    if (g._lines.Count != 0)
                    {
                        _primitiveSize += 3 + g._lines.Count * 2 * _fpStride;
                    }
                }
                else
                {
                    g.RegroupNodes();
                    for (int i = 0; i < g._headers.Count; i++)
                    {
                        _primitiveSize += 3 + g._facePoints[i].Count * _fpStride;
                    }
                }
 
                if (g._nodes.Count == 1 && g._nodes[0] == 0xFFFF)
                {
                    _isWeighted = false;
                }
 
                if (_isWeighted)
                {
                    _primitiveSize += 5 * g._nodes.Count * (HasTexMtx ? 3 : 2); //Add total matrices size
                }
            }
 
            return _primitiveSize;
        }

GetNormals()

Vector3[] BrawlLib.Modeling.PrimitiveManager.GetNormals ( bool  force )

inline

Retrieves normals from raw facedata in a remapped array.

Parameters

force

If not forced, will return values created by a previous call (if there was one).

Returns

        {
            if (_rawNormals != null && _rawNormals.Length != 0 && !force)
            {
                return _rawNormals;
            }
 
            HashSet<Vector3> list = new HashSet<Vector3>();
            if (_faceData[1] != null)
            {
                Vector3* pIn = (Vector3*) _faceData[1].Address;
                for (int i = 0; i < _pointCount; i++)
                {
                    list.Add(*pIn++);
                }
            }
 
            _rawNormals = new Vector3[list.Count];
            list.CopyTo(_rawNormals);
 
            return _rawNormals;
        }

GetUVs()

Vector2[] BrawlLib.Modeling.PrimitiveManager.GetUVs ( int  index, bool  force  )

inline

Retrieves texture coordinates from raw facedata in a remapped array.

Parameters

index	The UV set to retrieve. Values 0 - 7
force	If not forced, will return values created by a previous call (if there was one).

Returns

        {
            index = index.Clamp(0, 7);
 
            if (_uvs[index] != null && _uvs[index].Length != 0 && !force)
            {
                return _uvs[index];
            }
 
            HashSet<Vector2> list = new HashSet<Vector2>();
            if (_faceData[index + 4] != null)
            {
                Vector2* pIn = (Vector2*) _faceData[index + 4].Address;
                for (int i = 0; i < _pointCount; i++)
                {
                    list.Add(*pIn++);
                }
            }
 
            _uvs[index] = new Vector2[list.Count];
            list.CopyTo(_uvs[index]);
 
            return _uvs[index];
        }

GetVertices()

Vector3[] BrawlLib.Modeling.PrimitiveManager.GetVertices ( bool  force )

inline

Returns vertex positions from each vertex.

Parameters

force

If not forced, will return values created by a previous call (if there was one).

Returns

        {
            if (_rawVertices != null && _rawVertices.Length != 0 && !force)
            {
                return _rawVertices;
            }
 
            int i = 0;
            _rawVertices = new Vector3[_vertices.Count];
            foreach (Vertex3 v in _vertices)
            {
                _rawVertices[i++] = v.Position;
            }
 
            return _rawVertices;
        }

GroupPrimitives()

void BrawlLib.Modeling.PrimitiveManager.GroupPrimitives ( bool  useStrips, uint  cacheSize, uint  minStripLen, bool  pushCacheHits, bool  forceCCW, out int  newPointCount, out int  newFaceCount  )

inline

Currently should only should be called when importing a model with the collada importer or when internal asset data has changed and needs to be distributed to external arrays

        {
            TriangleConverter converter = new TriangleConverter(useStrips, cacheSize, minStripLen, pushCacheHits);
 
            _primGroups = new List<PrimitiveGroup>();
            newPointCount = 0;
            newFaceCount = 0;
 
            //Merge vertices and assets into facepoints
            Facepoint[] facepoints = MergeInternalFaceData();
            if (_triangles != null)
            {
                Facepoint[] points = new Facepoint[_triangles._indices.Length];
                uint[] indices = _triangles._indices;
 
                //Indices are written in reverse for each triangle, 
                //so they need to be set to a triangle in reverse if not CCW
                for (int t = 0; t < _triangles._indices.Length; t++)
                {
                    uint index = indices[t];
                    int pointIndex = forceCCW ? t : t - t % 3 + (2 - t % 3);
                    if (pointIndex < points.Length)
                    {
                        if (index >= facepoints.Length)
                        {
                            points[pointIndex] = new Facepoint();
                        }
                        else
                        {
                            points[pointIndex] = facepoints[index];
                        }
                    }
                }
 
                _primGroups.AddRange(converter.GroupPrimitives(points, out newPointCount, out newFaceCount));
            }
 
            if (_lines != null)
            {
                //TODO: combine into linestrips (not as urgent as tristrips was)
 
                Facepoint[] points = new Facepoint[_lines._indices.Length];
                uint[] indices = _lines._indices;
                for (int t = 0; t < indices.Length; t++)
                {
                    points[t] = facepoints[indices[t]];
                }
 
                List<PrimitiveGroup> groups = new List<PrimitiveGroup>();
 
                for (int i = 0; i < points.Length; i += 2)
                {
                    PointLine line = new PointLine(points[i], points[i + 1]);
 
                    bool added = false;
                    foreach (PrimitiveGroup g in groups)
                    {
                        if (added = g.TryAdd(line))
                        {
                            break;
                        }
                    }
 
                    if (!added)
                    {
                        PrimitiveGroup g = new PrimitiveGroup();
                        g.TryAdd(line);
                        groups.Add(g);
                    }
                }
 
                _primGroups.AddRange(groups);
            }
 
            if (_points != null)
            {
                Facepoint[] points = new Facepoint[_points._indices.Length];
                uint[] indices = _points._indices;
                for (int t = 0; t < indices.Length; t++)
                {
                    points[t] = facepoints[indices[t]];
                }
 
                List<PrimitiveGroup> groups = new List<PrimitiveGroup>();
 
                for (int i = 0; i < points.Length; i++)
                {
                    FPoint p = new FPoint(points[i]);
 
                    bool added = false;
                    foreach (PrimitiveGroup g in groups)
                    {
                        if (added = g.TryAdd(p))
                        {
                            break;
                        }
                    }
 
                    if (!added)
                    {
                        PrimitiveGroup g = new PrimitiveGroup();
                        g.TryAdd(p);
                        groups.Add(g);
                    }
                }
 
                _primGroups.AddRange(groups);
            }
        }

HardCopy()

PrimitiveManager BrawlLib.Modeling.PrimitiveManager.HardCopy ( )

inline

Returns an identical copy of this manager but as a completely new instance with reallocated buffers.

        {
            PrimitiveManager p = new PrimitiveManager
            {
                _vertices = _vertices,
                _indices = new UnsafeBuffer(_indices.Length),
                _pointCount = _pointCount,
                _faceCount = _faceCount,
                _faceData = new UnsafeBuffer[12],
                _triangles = _triangles == null
                    ? null
                    : new GLPrimitive(_triangles._indices.Length, BeginMode.Triangles),
                _lines = _lines == null ? null : new GLPrimitive(_lines._indices.Length, BeginMode.Lines),
                _points = _points == null ? null : new GLPrimitive(_points._indices.Length, BeginMode.Points),
                _dirty = new bool[] {true, true, true, true, true, true, true, true, true, true, true, true},
                _primGroups = _primGroups,
            };
            Memory.Move(p._indices.Address, _indices.Address, (uint) _indices.Length);
            for (int i = 0; i < 12; i++)
            {
                UnsafeBuffer b = _faceData[i];
                if (b == null)
                {
                    continue;
                }
 
                p._faceData[i] = new UnsafeBuffer(b.Length);
                Memory.Move(p._faceData[i].Address, b.Address, (uint) b.Length);
            }
 
            if (p._triangles != null)
            {
                _triangles._indices.CopyTo(p._triangles._indices, 0);
            }
 
            if (p._lines != null)
            {
                _lines._indices.CopyTo(p._lines._indices, 0);
            }
 
            if (p._points != null)
            {
                _points._indices.CopyTo(p._points._indices, 0);
            }
 
            p.HasTextureMatrix = new bool[8];
            HasTextureMatrix.CopyTo(p.HasTextureMatrix, 0);
            return p;
        }

NormalsChanged()

void BrawlLib.Modeling.PrimitiveManager.NormalsChanged ( MDL0ObjectNode  obj, bool  forceNewNode = false  )

inline

        {
            if (obj == null || obj.Deleting || _faceData[1] == null)
            {
                return;
            }
 
            SetAssetChanged(1);
            obj._forceRebuild = true;
            obj.SignalPropertyChange();
 
            MDL0NormalNode node;
            if (obj._normalNode != null)
            {
                if (obj._normalNode._objects.Count == 1 && !forceNewNode)
                {
                    node = obj._normalNode;
                }
                else
                {
                    node = new MDL0NormalNode();
                    MDL0Node m = obj.Model;
                    if (m.NormalGroup == null)
                    {
                        MDL0GroupNode g = new MDL0GroupNode(MDLResourceType.Normals);
                        m.LinkGroup(g);
                        g.Parent = m;
                    }
 
                    m.NormalGroup.AddChild(node);
                    node.Name = node.FindName("Regenerated");
                    if (obj._normalNode._objects.Contains(obj))
                    {
                        obj._normalNode._objects.Remove(obj);
                    }
 
                    obj._normalNode = node;
                    obj._normalNode._objects.Add(obj);
                    obj._elementIndices[1] = (short) obj._normalNode.Index;
                }
            }
            else
            {
                node = new MDL0NormalNode();
                MDL0Node m = obj.Model;
                if (m.NormalGroup == null)
                {
                    MDL0GroupNode g = new MDL0GroupNode(MDLResourceType.Normals);
                    m.LinkGroup(g);
                    g.Parent = m;
                }
 
                m.NormalGroup.AddChild(node);
                node.Name = node.FindName("Regenerated");
                obj._normalNode = node;
                obj._normalNode._objects.Add(obj);
                obj._elementIndices[1] = (short) obj._normalNode.Index;
            }
 
            node.Normals = GetNormals(true);
            Vector3* pData = (Vector3*) _faceData[1].Address;
            foreach (Vertex3 v in _vertices)
            {
                for (int i = 0; i < v.FaceDataIndices.Count; i++)
                {
                    v.Facepoints[i]._normalIndex = Array.IndexOf(node.Normals, pData[v.FaceDataIndices[i]]);
                }
            }
        }

PositionsChanged()

void BrawlLib.Modeling.PrimitiveManager.PositionsChanged ( MDL0ObjectNode  obj, bool  forceNewNode = false  )

inline

        {
            if (obj == null || obj.Deleting || _vertices == null)
            {
                return;
            }
 
            SetAssetChanged(0);
            obj._forceRebuild = true;
            obj.SignalPropertyChange();
 
            MDL0VertexNode node;
            if (obj._vertexNode != null)
            {
                if (obj._vertexNode._objects.Count == 1 && !forceNewNode)
                {
                    node = obj._vertexNode;
                }
                else
                {
                    node = new MDL0VertexNode();
                    MDL0Node m = obj.Model;
                    if (m.VertexGroup == null)
                    {
                        MDL0GroupNode g = new MDL0GroupNode(MDLResourceType.Vertices);
                        m.LinkGroup(g);
                        g.Parent = m;
                    }
 
                    m.VertexGroup.AddChild(node);
                    node.Name = node.FindName("Regenerated");
                    if (obj._vertexNode._objects.Contains(obj))
                    {
                        obj._vertexNode._objects.Remove(obj);
                    }
 
                    obj._vertexNode = node;
                    obj._vertexNode._objects.Add(obj);
                    obj._elementIndices[0] = (short) obj._vertexNode.Index;
                }
            }
            else
            {
                node = new MDL0VertexNode();
                MDL0Node m = obj.Model;
                if (m.VertexGroup == null)
                {
                    MDL0GroupNode g = new MDL0GroupNode(MDLResourceType.Vertices);
                    m.LinkGroup(g);
                    g.Parent = m;
                }
 
                m.VertexGroup.AddChild(node);
                node.Name = node.FindName("Regenerated");
                obj._vertexNode = node;
                obj._vertexNode._objects.Add(obj);
                obj._elementIndices[0] = (short) obj._vertexNode.Index;
            }
 
            node.Vertices = GetVertices(true);
            int x = 0;
            foreach (Vertex3 v in _vertices)
            {
                foreach (Facepoint f in v.Facepoints)
                {
                    f._vertexIndex = x;
                    f._vertex = v;
                }
 
                x++;
            }
        }

PrepareStream()

void BrawlLib.Modeling.PrimitiveManager.PrepareStream ( )

inline

        {
            CalcStride();
            int bufferSize = _renderStride * _pointCount;
 
            //Dispose of buffer if size doesn't match
            if (_graphicsBuffer != null && _graphicsBuffer.Length != bufferSize)
            {
                _graphicsBuffer.Dispose();
                _graphicsBuffer = null;
            }
 
            //Create data buffer
            if (_graphicsBuffer == null)
            {
                _graphicsBuffer = new UnsafeBuffer(bufferSize);
                for (int i = 0; i < 12; i++)
                {
                    _dirty[i] = true;
                }
            }
 
            //Update streams before binding
            for (int i = 0; i < 12; i++)
            {
                if (_dirty[i])
                {
                    UpdateStream(i);
                }
            }
        }

RenderMesh()

void BrawlLib.Modeling.PrimitiveManager.RenderMesh ( )

inline

        {
            _triangles?.Render();
 
            _lines?.Render();
 
            _points?.Render();
        }

SetAssetChanged()

void BrawlLib.Modeling.PrimitiveManager.SetAssetChanged ( int  index )

inline

        {
            //Signal that facepoints need to be reindexed with a new asset array
            _changed[index] = true;
 
            //Update render buffer
            _dirty[index] = true;
        }

SetFormatList()

void BrawlLib.Modeling.PrimitiveManager.SetFormatList ( MDL0ObjectNode  polygon, ModelLinker  linker  )

inline

        {
            _fmtList = new List<VertexAttributeFormat>();
            VertexCodec vert = null;
            ColorCodec col = null;
 
            for (int i = 0; i < 12; i++)
            {
                if (polygon._manager._faceData[i] != null)
                {
                    switch (i)
                    {
                        case 0: //Positions
                            if (linker._vertices != null && linker._vertices.Count != 0 &&
                                polygon._elementIndices[0] != -1)
                            {
                                if ((vert = linker._vertices[polygon._elementIndices[0]]) != null)
                                {
                                    _fmtList.Add(new VertexAttributeFormat(
                                        GXAttribute.Position,
                                        (GXCompType) vert._type,
                                        (GXCompCnt) (vert._hasZ ? 1 : 0),
                                        (byte) vert._scale));
                                }
                            }
 
                            break;
                        case 1: //Normals
                            vert = null;
                            if (linker._normals != null && linker._normals.Count != 0 &&
                                polygon._elementIndices[1] != -1)
                            {
                                if ((vert = linker._normals[polygon._elementIndices[1]]) != null)
                                {
                                    _fmtList.Add(new VertexAttributeFormat(
                                        GXAttribute.Normal,
                                        (GXCompType) vert._type,
                                        GXCompCnt.NrmXYZ,
                                        (byte) vert._scale));
                                }
                            }
 
                            break;
                        case 2: //Color 1
                        case 3: //Color 2
                            col = null;
                            if (linker._colors != null && linker._colors.Count != 0 &&
                                polygon._elementIndices[i] != -1 &&
                                (col = linker._colors[polygon._elementIndices[i]]) != null)
                            {
                                _fmtList.Add(new VertexAttributeFormat(
                                    (GXAttribute) ((int) GXAttribute.Color0 + (i - 2)),
                                    (GXCompType) col._outType,
                                    (GXCompCnt) (col._hasAlpha ? 1 : 0),
                                    0));
                            }
 
                            break;
                        case 4:  //Tex 1
                        case 5:  //Tex 2
                        case 6:  //Tex 3
                        case 7:  //Tex 4
                        case 8:  //Tex 5
                        case 9:  //Tex 6
                        case 10: //Tex 7
                        case 11: //Tex 8
                            vert = null;
                            if (linker._uvs != null && linker._uvs.Count != 0 && polygon._elementIndices[i] != -1)
                            {
                                if ((vert = linker._uvs[polygon._elementIndices[i]]) != null)
                                {
                                    _fmtList.Add(new VertexAttributeFormat(
                                        (GXAttribute) ((int) GXAttribute.Tex0 + (i - 4)),
                                        (GXCompType) vert._type,
                                        GXCompCnt.TexST,
                                        (byte) vert._scale));
                                }
                            }
 
                            break;
                    }
                }
            }
        }

SetVertexDescList()

void BrawlLib.Modeling.PrimitiveManager.SetVertexDescList ( short[]  indices, List< VertexCodec >  vertexCodecs, List< ColorCodec >  colorCodecs, params bool[]  forceDirect  )

inline

        {
            //Everything is set in the order the facepoint is written!
 
            //Create new command list
            _descList = new List<FacepointAttribute>();
            _fpStride = 0;
            XFDataFormat fmt;
            _arrayFlags = new XFArrayFlags {_data = 0};
 
            if (_isWeighted)
            {
                _descList.Add(new FacepointAttribute(GXAttribute.PosNrmMtxId, XFDataFormat.Direct));
                _fpStride++;
                _arrayFlags.HasPosMatrix = true;
 
                //There are no texture matrices without a position/normal matrix also
                for (int i = 0; i < 8; i++)
                {
                    if (HasTextureMatrix[i])
                    {
                        _descList.Add(new FacepointAttribute((GXAttribute) (i + 1), XFDataFormat.Direct));
                        _fpStride++;
                        _arrayFlags.SetHasTexMatrix(i, true);
                    }
                }
            }
 
            if (indices[0] > -1 && _faceData[0] != null) //Positions
            {
                _arrayFlags.HasPositions = true;
                fmt = forceDirect != null && forceDirect.Length > 0 && forceDirect[0]
                    ? XFDataFormat.Direct
                    : (XFDataFormat) (GetVertices(false).Length > byte.MaxValue ? 3 : 2);
                _descList.Add(new FacepointAttribute(GXAttribute.Position, fmt));
 
                //if (fmt == XFDataFormat.Direct)
                //{
                //    _fpStride += linker._vertices[indices[0]]._dstStride;
                //}
                //else
                _fpStride += (int) fmt - 1;
            }
 
            if (indices[1] > -1 && _faceData[1] != null) //Normals
            {
                _arrayFlags.HasNormals = true;
                fmt = forceDirect != null && forceDirect.Length > 1 && forceDirect[1]
                    ? XFDataFormat.Direct
                    : (XFDataFormat) (GetNormals(false).Length > byte.MaxValue ? 3 : 2);
                _descList.Add(new FacepointAttribute(GXAttribute.Normal, fmt));
 
                //if (fmt == XFDataFormat.Direct)
                //{
                //    _fpStride += linker._normals[indices[1]]._dstStride;
                //}
                //else
                _fpStride += (int) fmt - 1;
            }
 
            for (int i = 2; i < 4; i++)
            {
                if (indices[i] > -1 && _faceData[i] != null) //Colors
                {
                    _arrayFlags.SetHasColor(i - 2, true);
 
                    fmt = forceDirect != null && forceDirect.Length > i && forceDirect[i]
                        ? XFDataFormat.Direct
                        : (XFDataFormat) (GetColors(i - 2, false).Length > byte.MaxValue ? 3 : 2);
 
                    _descList.Add(new FacepointAttribute((GXAttribute) (i + 9), fmt));
 
                    //if (fmt == XFDataFormat.Direct)
                    //{
                    //    _fpStride +=  linker._colors[indices[i]]._dstStride;
                    //}
                    //else
                    _fpStride += (int) fmt - 1;
                }
            }
 
            for (int i = 4; i < 12; i++)
            {
                if (indices[i] > -1 && _faceData[i] != null) //UVs
                {
                    _arrayFlags.SetHasUVs(i - 4, true);
                    fmt = forceDirect != null && forceDirect.Length > i && forceDirect[i]
                        ? XFDataFormat.Direct
                        : (XFDataFormat) (GetUVs(i - 4, false).Length > byte.MaxValue ? 3 : 2);
                    _descList.Add(new FacepointAttribute((GXAttribute) (i + 9), fmt));
 
                    //if (fmt == XFDataFormat.Direct)
                    //{
                    //    _fpStride += linker._uvs[indices[i]]._dstStride;
                    //}
                    //else
                    _fpStride += (int) fmt - 1;
                }
            }
        }

ShiftUVATA()

uint BrawlLib.Modeling.PrimitiveManager.ShiftUVATA ( uint  posCnt, uint  posFmt, uint  posShft, uint  nrmCnt, uint  nrmFmt, uint  Col0Cnt, uint  Col0Fmt, uint  Col1Cnt, uint  Col1Fmt, uint  tex0Cnt, uint  tex0Fmt, uint  tex0Shft, uint  normalIndex3  )

inline

        {
            return (posCnt << 0) |
                   (posFmt << 1) |
                   (posShft << 4) |
                   (nrmCnt << 9) |
                   (nrmFmt << 10) |
                   (Col0Cnt << 13) |
                   (Col0Fmt << 14) |
                   (Col1Cnt << 17) |
                   (Col1Fmt << 18) |
                   (tex0Cnt << 21) |
                   (tex0Fmt << 22) |
                   (tex0Shft << 25) |
                   ((uint) 1 << 30) | //Should always be 1
                   (normalIndex3 << 31);
        }

ShiftUVATB()

uint BrawlLib.Modeling.PrimitiveManager.ShiftUVATB ( uint  tex1Cnt, uint  tex1Fmt, uint  tex1Shft, uint  tex2Cnt, uint  tex2Fmt, uint  tex2Shft, uint  tex3Cnt, uint  tex3Fmt, uint  tex3Shft, uint  tex4Cnt, uint  tex4Fmt  )

inline

        {
            return (tex1Cnt << 0) |
                   (tex1Fmt << 1) |
                   (tex1Shft << 4) |
                   (tex2Cnt << 9) |
                   (tex2Fmt << 10) |
                   (tex2Shft << 13) |
                   (tex3Cnt << 18) |
                   (tex3Fmt << 19) |
                   (tex3Shft << 22) |
                   (tex4Cnt << 27) |
                   (tex4Fmt << 28) |
                   ((uint) 1 << 31); //Should always be 1
        }

ShiftUVATC()

uint BrawlLib.Modeling.PrimitiveManager.ShiftUVATC ( uint  tex4Shft, uint  tex5Cnt, uint  tex5Fmt, uint  tex5Shft, uint  tex6Cnt, uint  tex6Fmt, uint  tex6Shft, uint  tex7Cnt, uint  tex7Fmt, uint  tex7Shft  )

inline

        {
            return (tex4Shft << 0) |
                   (tex5Cnt << 5) |
                   (tex5Fmt << 6) |
                   (tex5Shft << 9) |
                   (tex6Cnt << 14) |
                   (tex6Fmt << 15) |
                   (tex6Shft << 18) |
                   (tex7Cnt << 23) |
                   (tex7Fmt << 24) |
                   (tex7Shft << 27);
        }

ShiftVtxHi()

uint BrawlLib.Modeling.PrimitiveManager.ShiftVtxHi ( uint  tex0, uint  tex1, uint  tex2, uint  tex3, uint  tex4, uint  tex5, uint  tex6, uint  tex7  )

inline

        {
            return (tex0 << 0) |
                   (tex1 << 2) |
                   (tex2 << 4) |
                   (tex3 << 6) |
                   (tex4 << 8) |
                   (tex5 << 10) |
                   (tex6 << 12) |
                   (tex7 << 14);
        }

ShiftVtxLo()

uint BrawlLib.Modeling.PrimitiveManager.ShiftVtxLo ( uint  pmidx, uint  t76543210midx, uint  pos, uint  nrm, uint  col0, uint  col1  )

inline

        {
            return (pmidx << 0) |
                   (t76543210midx << 1) |
                   (pos << 9) |
                   (nrm << 11) |
                   (col0 << 13) |
                   (col1 << 15);
        }

ShiftXFSpecs()

uint BrawlLib.Modeling.PrimitiveManager.ShiftXFSpecs ( uint  host_colors, uint  host_normal, uint  host_textures  )

inline

        {
            return (host_colors << 0) |
                   (host_normal << 2) |
                   (host_textures << 4);
        }

Unweight()

void BrawlLib.Modeling.PrimitiveManager.Unweight ( bool  updateAssets )

inline

        {
            if (_vertices != null)
            {
                foreach (Vertex3 v in _vertices)
                {
                    v.Unweight(updateAssets);
                }
            }
        }

UVsChanged()

void BrawlLib.Modeling.PrimitiveManager.UVsChanged ( MDL0ObjectNode  obj, int  id, bool  forceNewNode = false  )

inline

        {
            id = id.Clamp(0, 7);
 
            if (obj == null || _faceData[id + 4] == null)
            {
                return;
            }
 
            SetAssetChanged(id + 4);
            obj._forceRebuild = true;
            obj.SignalPropertyChange();
 
            MDL0UVNode node;
            if (obj._uvSet[id] != null)
            {
                if (obj._uvSet[id]._objects.Count == 1 && !forceNewNode)
                {
                    node = obj._uvSet[id];
                }
                else
                {
                    node = new MDL0UVNode();
                    obj.Model.UVGroup.AddChild(node);
                    node.Name = node.FindName("Regenerated");
                    if (obj._uvSet[id]._objects.Contains(obj))
                    {
                        obj._uvSet[id]._objects.Remove(obj);
                    }
 
                    obj._uvSet[id] = node;
                    obj._uvSet[id]._objects.Add(obj);
                    obj._elementIndices[id + 4] = (short) obj._uvSet[id].Index;
                }
            }
            else
            {
                node = new MDL0UVNode();
                MDL0Node m = obj.Model;
                if (m.UVGroup == null)
                {
                    MDL0GroupNode g = new MDL0GroupNode(MDLResourceType.UVs);
                    m.LinkGroup(g);
                    g.Parent = m;
                }
 
                m.UVGroup.AddChild(node);
                node.Name = node.FindName("Regenerated");
                obj._uvSet[id] = node;
                obj._uvSet[id]._objects.Add(obj);
                obj._elementIndices[id + 4] = (short) obj._uvSet[id].Index;
            }
 
            node.Points = GetUVs(id, true);
            Vector2* pData = (Vector2*) _faceData[id + 4].Address;
            foreach (Vertex3 v in _vertices)
            {
                for (int i = 0; i < v.FaceDataIndices.Count; i++)
                {
                    v.Facepoints[i]._UVIndices[id] = Array.IndexOf(node.Points, pData[v.FaceDataIndices[i]]);
                }
            }
        }

Weight()

void BrawlLib.Modeling.PrimitiveManager.Weight ( )

inline

        {
            //Weight vertices
            if (_vertices != null)
            {
                foreach (Vertex3 v in _vertices)
                {
                    v.Weight();
                }
            }
 
            //Update graphics buffer with weighted data on next render
            _dirty[0] = true;
            _dirty[1] = true;
        }

WriteVertexDescriptor()

void BrawlLib.Modeling.PrimitiveManager.WriteVertexDescriptor ( out CPVertexFormat  vertexFormat, out XFVertexSpecs  vertexSpecs  )

inline

This sets up how to read the facepoints that are going to be written.

        {
            XFNormalFormat nrmFmt = XFNormalFormat.None;
            int numColors = 0;
            int numUVs = 0;
 
            uint posNrmMtxId = 0;
            uint texMtxIdMask = 0;
            uint pos = 0;
            uint nrm = 0;
            uint col0 = 0;
            uint col1 = 0;
            uint tex0 = 0;
            uint tex1 = 0;
            uint tex2 = 0;
            uint tex3 = 0;
            uint tex4 = 0;
            uint tex5 = 0;
            uint tex6 = 0;
            uint tex7 = 0;
 
            foreach (FacepointAttribute attrPtr in _descList)
            {
                switch (attrPtr._attr)
                {
                    case GXAttribute.PosNrmMtxId:
                        posNrmMtxId = (uint) attrPtr._type;
                        break;
 
                    case GXAttribute.Tex0MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~1) | ((uint) attrPtr._type << 0);
                        break;
                    case GXAttribute.Tex1MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~2) | ((uint) attrPtr._type << 1);
                        break;
                    case GXAttribute.Tex2MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~4) | ((uint) attrPtr._type << 2);
                        break;
                    case GXAttribute.Tex3MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~8) | ((uint) attrPtr._type << 3);
                        break;
                    case GXAttribute.Tex4MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~16) | ((uint) attrPtr._type << 4);
                        break;
                    case GXAttribute.Tex5MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~32) | ((uint) attrPtr._type << 5);
                        break;
                    case GXAttribute.Tex6MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~64) | ((uint) attrPtr._type << 6);
                        break;
                    case GXAttribute.Tex7MtxId:
                        texMtxIdMask = (uint) (texMtxIdMask & ~128) | ((uint) attrPtr._type << 7);
                        break;
 
                    case GXAttribute.Position:
                        pos = (uint) attrPtr._type;
                        break;
 
                    case GXAttribute.Normal:
                        if (attrPtr._type != XFDataFormat.None)
                        {
                            nrm = (uint) attrPtr._type;
                            nrmFmt = XFNormalFormat.XYZ;
                        }
 
                        break;
 
                    case GXAttribute.NBT:
                        if (attrPtr._type != XFDataFormat.None)
                        {
                            nrm = (uint) attrPtr._type;
                            nrmFmt = XFNormalFormat.NBT;
                        }
 
                        break;
 
                    case GXAttribute.Color0:
                        col0 = (uint) attrPtr._type;
                        numColors += col0 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Color1:
                        col1 = (uint) attrPtr._type;
                        numColors += col1 != 0 ? 1 : 0;
                        break;
 
                    case GXAttribute.Tex0:
                        tex0 = (uint) attrPtr._type;
                        numUVs += tex0 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex1:
                        tex1 = (uint) attrPtr._type;
                        numUVs += tex1 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex2:
                        tex2 = (uint) attrPtr._type;
                        numUVs += tex2 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex3:
                        tex3 = (uint) attrPtr._type;
                        numUVs += tex3 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex4:
                        tex4 = (uint) attrPtr._type;
                        numUVs += tex4 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex5:
                        tex5 = (uint) attrPtr._type;
                        numUVs += tex5 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex6:
                        tex6 = (uint) attrPtr._type;
                        numUVs += tex6 != 0 ? 1 : 0;
                        break;
                    case GXAttribute.Tex7:
                        tex7 = (uint) attrPtr._type;
                        numUVs += tex7 != 0 ? 1 : 0;
                        break;
                }
            }
 
            vertexSpecs = new XFVertexSpecs(numColors, numUVs, nrmFmt);
            vertexFormat = new CPVertexFormat(
                ShiftVtxLo(posNrmMtxId, texMtxIdMask, pos, nrm, col0, col1),
                ShiftVtxHi(tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7));
        }

WriteVertexFormat()

void BrawlLib.Modeling.PrimitiveManager.WriteVertexFormat ( MDL0Object *  polygon )

inline

        {
            //These are default values.
 
            uint posCnt = (int) GXCompCnt.PosXYZ;
            uint posType = (int) GXCompType.Float;
            uint posFrac = 0;
 
            uint nrmCnt = (int) GXCompCnt.NrmXYZ;
            uint nrmType = (int) GXCompType.Float;
            uint nrmId3 = 0;
 
            uint c0Cnt = (int) GXCompCnt.ClrRGBA;
            uint c0Type = (int) GXCompType.RGBA8;
            uint c1Cnt = (int) GXCompCnt.ClrRGBA;
            uint c1Type = (int) GXCompType.RGBA8;
 
            uint tx0Cnt = (int) GXCompCnt.TexST;
            uint tx0Type = (int) GXCompType.Float;
            uint tx0Frac = 0;
            uint tx1Cnt = (int) GXCompCnt.TexST;
            uint tx1Type = (int) GXCompType.Float;
            uint tx1Frac = 0;
            uint tx2Cnt = (int) GXCompCnt.TexST;
            uint tx2Type = (int) GXCompType.Float;
            uint tx2Frac = 0;
            uint tx3Cnt = (int) GXCompCnt.TexST;
            uint tx3Type = (int) GXCompType.Float;
            uint tx3Frac = 0;
            uint tx4Cnt = (int) GXCompCnt.TexST;
            uint tx4Type = (int) GXCompType.Float;
            uint tx4Frac = 0;
            uint tx5Cnt = (int) GXCompCnt.TexST;
            uint tx5Type = (int) GXCompType.Float;
            uint tx5Frac = 0;
            uint tx6Cnt = (int) GXCompCnt.TexST;
            uint tx6Type = (int) GXCompType.Float;
            uint tx6Frac = 0;
            uint tx7Cnt = (int) GXCompCnt.TexST;
            uint tx7Type = (int) GXCompType.Float;
            uint tx7Frac = 0;
 
            if (_fmtList != null)
            {
                foreach (VertexAttributeFormat list in _fmtList)
                {
                    switch (list._attr)
                    {
                        case GXAttribute.Position:
                            posCnt = (uint) list._cnt;
                            posType = (uint) list._type;
                            posFrac = list._frac;
                            break;
                        case GXAttribute.Normal:
                        case GXAttribute.NBT:
                            nrmType = (uint) list._type;
                            if (list._cnt == GXCompCnt.NrmNBT3)
                            {
                                nrmCnt = (uint) GXCompCnt.NrmNBT;
                                nrmId3 = 1;
                            }
                            else
                            {
                                nrmCnt = (uint) list._cnt;
                                nrmId3 = 0;
                            }
 
                            break;
                        case GXAttribute.Color0:
                            c0Cnt = (uint) list._cnt;
                            c0Type = (uint) list._type;
                            break;
                        case GXAttribute.Color1:
                            c1Cnt = (uint) list._cnt;
                            c1Type = (uint) list._type;
                            break;
                        case GXAttribute.Tex0:
                            tx0Cnt = (uint) list._cnt;
                            tx0Type = (uint) list._type;
                            tx0Frac = list._frac;
                            break;
                        case GXAttribute.Tex1:
                            tx1Cnt = (uint) list._cnt;
                            tx1Type = (uint) list._type;
                            tx1Frac = list._frac;
                            break;
                        case GXAttribute.Tex2:
                            tx2Cnt = (uint) list._cnt;
                            tx2Type = (uint) list._type;
                            tx2Frac = list._frac;
                            break;
                        case GXAttribute.Tex3:
                            tx3Cnt = (uint) list._cnt;
                            tx3Type = (uint) list._type;
                            tx3Frac = list._frac;
                            break;
                        case GXAttribute.Tex4:
                            tx4Cnt = (uint) list._cnt;
                            tx4Type = (uint) list._type;
                            tx4Frac = list._frac;
                            break;
                        case GXAttribute.Tex5:
                            tx5Cnt = (uint) list._cnt;
                            tx5Type = (uint) list._type;
                            tx5Frac = list._frac;
                            break;
                        case GXAttribute.Tex6:
                            tx6Cnt = (uint) list._cnt;
                            tx6Type = (uint) list._type;
                            tx6Frac = list._frac;
                            break;
                        case GXAttribute.Tex7:
                            tx7Cnt = (uint) list._cnt;
                            tx7Type = (uint) list._type;
                            tx7Frac = list._frac;
                            break;
                    }
                }
            }
 
            MDL0PolygonDefs* Defs = polygon->DefList;
            Defs->UVATA = ShiftUVATA(posCnt, posType, posFrac, nrmCnt, nrmType, c0Cnt, c0Type, c1Cnt, c1Type, tx0Cnt,
                tx0Type, tx0Frac, nrmId3);
            Defs->UVATB = ShiftUVATB(tx1Cnt, tx1Type, tx1Frac, tx2Cnt, tx2Type, tx2Frac, tx3Cnt, tx3Type, tx3Frac,
                tx4Cnt, tx4Type);
            Defs->UVATC = ShiftUVATC(tx4Frac, tx5Cnt, tx5Type, tx5Frac, tx6Cnt, tx6Type, tx6Frac, tx7Cnt, tx7Type,
                tx7Frac);
        }

Member Data Documentation

_arrayBufferHandle

int BrawlLib.Modeling.PrimitiveManager._arrayBufferHandle

_arrayFlags

XFArrayFlags BrawlLib.Modeling.PrimitiveManager._arrayFlags

_arrayHandle

int BrawlLib.Modeling.PrimitiveManager._arrayHandle

_descList

List<FacepointAttribute> BrawlLib.Modeling.PrimitiveManager._descList

_dirty

bool [] BrawlLib.Modeling.PrimitiveManager._dirty = new bool[12]

_elementArrayBufferHandle

int BrawlLib.Modeling.PrimitiveManager._elementArrayBufferHandle

_faceCount

int BrawlLib.Modeling.PrimitiveManager._faceCount

_faceData

UnsafeBuffer [] BrawlLib.Modeling.PrimitiveManager._faceData = new UnsafeBuffer[12]

_fmtList

List<VertexAttributeFormat> BrawlLib.Modeling.PrimitiveManager._fmtList

_fpStride

int BrawlLib.Modeling.PrimitiveManager._fpStride

_graphicsBuffer

UnsafeBuffer BrawlLib.Modeling.PrimitiveManager._graphicsBuffer

_indices

UnsafeBuffer BrawlLib.Modeling.PrimitiveManager._indices

_isWeighted

bool BrawlLib.Modeling.PrimitiveManager._isWeighted

_nodeRadius

const float BrawlLib.Modeling.PrimitiveManager._nodeRadius = 0.05f

static

_pointCount

int BrawlLib.Modeling.PrimitiveManager._pointCount

_primGroups

List<PrimitiveGroup> BrawlLib.Modeling.PrimitiveManager._primGroups = new List<PrimitiveGroup>()

_primitiveSize

int BrawlLib.Modeling.PrimitiveManager._primitiveSize

_remakePrimitives

bool BrawlLib.Modeling.PrimitiveManager._remakePrimitives

_render

bool BrawlLib.Modeling.PrimitiveManager._render = true

_renderNormals

bool BrawlLib.Modeling.PrimitiveManager._renderNormals = true

_renderStride

int BrawlLib.Modeling.PrimitiveManager._renderStride

_vertices

List<Vertex3> BrawlLib.Modeling.PrimitiveManager._vertices

DefaultNormColor

Color BrawlLib.Modeling.PrimitiveManager.DefaultNormColor = Color.FromArgb(0, 0, 128)

static

DefaultVertColor

Color BrawlLib.Modeling.PrimitiveManager.DefaultVertColor = Color.FromArgb(0, 128, 0)

static

HasTextureMatrix

bool [] BrawlLib.Modeling.PrimitiveManager.HasTextureMatrix = new bool[8]

NormalLength

float BrawlLib.Modeling.PrimitiveManager.NormalLength = 0.5f

static

UseIdentityTexMtx

bool [] BrawlLib.Modeling.PrimitiveManager.UseIdentityTexMtx = new bool[8]

Property Documentation

AssetsChanged

bool BrawlLib.Modeling.PrimitiveManager.AssetsChanged

getset

        {
            get
            {
                foreach (bool b in _changed)
                {
                    if (b)
                    {
                        return true;
                    }
                }
 
                return false;
            }
            set
            {
                for (int i = 0; i < _changed.Length; i++)
                {
                    _changed[i] = false;
                }
            }
        }

HasTexMtx

bool BrawlLib.Modeling.PrimitiveManager.HasTexMtx

get

        {
            get
            {
                for (int i = 0; i < 8; i++)
                {
                    if (HasTextureMatrix[i])
                    {
                        return true;
                    }
                }
 
                return false;
            }
        }

---

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

• BrawlLib/Modeling/PrimitiveManager.cs