[DirectX / 3D / C#] Indexbuffer en polygonen

[Verwijderd]

Goeienavond,

Ik ben bezig met een hobby projectje om Managed DirectX te leren. Hiervoor ben ik nu een functie aan het schrijven die meshes van een bestaand, oud spel in moet gaan lezen. Het bestandsformaat (PIE) is afkomstig van Warzone 2100, voor het geval dat iemand het wilt weten of het misschien nuttige info is.

In dit PIE formaat zit de info over de mesh opgeslagen in een vertex lijst en een lijst van polygons met verwijzing naar de vertices, dus in principe is het een kwestie van de vertices inlezen en in een vertexbuffer stoppen en vervolgens de polygonen in te lezen in een indexbuffer en dan deze gebruiken om de mesh te renderen, toch? Goed...

Het probleem

In het PIE formaat zijn polygonen van een hogere graad dan triangles toegestaan. In principe zijn alle graden zo'n beetje geldig (voor zover ik het bestandsformaat heb kunnen ontleden) en ze worden vrolijk door elkaar gebruikt, maar ik denk dat dit op te lossen is door ze als TriangleFan te renderen.

Mijn probleem is alleen dat ik geen flauw idee heb hoe ik dit met de indexbuffer aan de praat moet krijgen. Alle voorbeelden die ik van de indexbuffer heb gezien gebruiken Triangles als polygonen, dus dat schoot al niet op. Kan ik niet gewoon een array van arrays meegeven aan de indexbuffer als data? Zo zou ik (vanuit mijn n00b C# / DirectX oogpunt) verschillende vormen polygonen eenvoudig moeten kunnen renderen met een enkele call naar DrawIndexedPrimitives(PrimitiveType.TriangleFan...), niet?

Alleen... een indexbuffer aanmaken met typeof(short[]) was geen succes. Ongetwijfeld doe ik wat heel simpels fout, dus als iemand ziet waar het fout gaat, of een alternatief weet, dan hoor ik het graag

[Woy]

Waarschijnlijk is het het makkelijkst om de polygonen die uit meer dan 3 vertexes bestaan te trianguleren. Zo houd je alleen triangles over en kan je gewoon gebruik maken van een standaard IndexBuffer en VertexBuffer

[.oisyn]

Een trianglefan is gewoon een enkele lijst van vertices die de fan definieert (staat in de MSDN!). Een trianglefan met indices 0,1,2,3,4,5 betekent dus simpelweg triangles die index 0 als gesharede vertex hebben (oftewel de triangles (0,1,2), (0,2,3), (0,3,4), (0,4,5)).

Dat is echter niet wat je wilt; je zult voor elke polygoon een drawindexedprimitive call moeten doen, en dat is enorm duur. Als je de polygonen gewoon opdeelt in triangles (kan volgens diezelfde trianglefan methode, ze zijn immers convex) kun je hele submeshes (groepen triangles met dezelfde properties, zoals textures) in een keer renderen.

[Verwijderd]

Kan je niet proberen je formaat om te zetten naar een *.x formaat. Je hebt hiervoor genoeg tools op het web....

[Verwijderd]

Helaas is het een ouder formaat (1999) voor 1 redelijk onbekend spel, dus er zijn geen goede converters beschikbaar omzetten naar een .X file. Er is wel ooit een converter geschreven door een 3D hobbyist zoals ik, maar die werkte aleen voor DX7 en daarvan is de code zoek... Daarnaast zitten er wat features in het PIE formaat die volgens mij met een standaard .X file lastig te implementeren zijn.

.Oisin, bedankt voor het toelichten van de TriangleFan (en dat het in de MSDN staat! ). Ik had zelf ook al zo'n vermoeden dat het niet efficient zou zijn om de polygonen allemaal stuk voor stuk te gaan tekenenen. Ik had gehoopt dat het mogelijk was om andere vormen dan triangles in de indexbuffer op te slaan (dmv. de boven beschreven array truc), die dan als TriangleFan in 1 call getekend konden worden. Maar dat gaat dus blijkbaar niet.

Ik ben me wat gaan verdiepen in triangulation, maar ik vond niet echt een bruikbaar codevoorbeeld. Ik heb flink gegoogled, maar de meeste voorbeelden gaan over terain-mapping d.m.v. triangulation van hoogtepunten of simpele 2D triangulation voorbeelden. Dus heb ik zelf wat bedacht:

LET OP! DEZE CODE IS FOUT, ZIE BENEDEN VOOR DE GOEDE CODE!

code:

        private int[][] TriangulatePolygon( int[] polyIndices )
        {           
            
            int triangleCount = polyIndices.Length - 2;
            int[][] triangles = new int[triangleCount][];

            for(int i = 0; i < triangleCount; i++)
            {
                triangles[i] = new int[] { polyIndices[0], polyIndices[i] + 1, polyIndices[i] + 2 };
            }

            return triangles;
        }

^{En ja, ik ben een Java convert dus het kan ongetwijfeld efficienter!}

Uit de info die ik later nog gevonden heb, is dit een bestaand algoritme (Fournier and Montuno, 1984) dat gewoon zou moeten werken voor monotone ( en dus convex? ) polygons. Alleen ziet het zo ingelezen en getrianguleerde model er in mijn programma nog niet goed uit.

De vraag is nu een beetje of het aan mijn Triangulatie code ligt, of dat er nog meer aangepast moet worden aan de data uit het PIE formaat, of dat ik het PIE formaat helemaal niet snap! . Dus als iemand bovenstaande code even zou willen doorkijken om te zien of het inderdaad goed trianguleert, of een alternatief kan aanreiken, dan hoor ik het graag!


ps. Heeft DX9 voor Managed Code hier geen standaard functie voor?

[ Voor 3% gewijzigd door Verwijderd op 25-03-2005 16:54 ]

[CodeCaster]

Code ziet er goed uit, kun je niet een stukje van het bestand posten?

Dan denk ik dat ik je wel kan helpen

Edit: Het spel inclusief broncode is gratis te downloaden, mss heb je daar wat aan?

http://www.angelfire.com/...ieSlicer_DX_v082_Full.zip

De PIE slicer voor DirectX, mss kun je daar ook iets mee?

[ Voor 51% gewijzigd door CodeCaster op 24-03-2005 10:03 ]

[Woy]

Als ik zo snel naar je voorbeeld kijk dan zal het opdelen van de triangles wel goed gaan. Geef je niet het verkeerde type List me. Als je gewoon eerst eens een TriangleList meegeeft hoef je ieder geval geen rekening te houden met de volgorde van je Triangles. Dan kan je dat later altijd nog weer vervangen voor een TriangleFan of TriangleStrip. Je kan ook eens proberen om bijvoorbeeld de culling uit te zetten zodat je al je triangles ziet. Het zou namelijk best kunnen dat je een aantal Triangles in je mesh de face de verkeerde kant op kijken.

Voor de rest hoeft een Triangulatie algoritme echt niet zo moeilijk te zijn, en lijkt bovendien ook erg veel op de 2D variant.
Als je bijvoorbeeld een non covexe polygoon heb kan je die gewoon trianguleren door telkens een triangle te zoeken waarvan de 3e zijde compleet binnen de polygoon valt. Deze kan je er dan afhalen en zo kan je het proces blijven herhalen totdat je nog maar 1 triangle ( of natuurlijk een covexe polygoon ) overhoud.

[CodeCaster]

Hier een POLYGON regel uit een PIE bestand:

200 4 3 2 1 0 18 176 18 165 4 165 4 176

Wat is het?

200 = ?
4 = Aantal indexen
3 2 1 0 = indexen
18 176 = tu, tv
18 165 = tu, tv
4 165 = tu, tv
4 176 = tu, tv

Neem ik aan?

Mss dat, wanneer je als volgt rendert, het wel werkt:

3 2 1 0:

Tri 1: 3 2 1
Tri 2: 2 1 0

?

[MrBucket]

Ik zie niet in waarom men modellen voor een spel zodanig zou willen opslaan, dat men ze na het inladen alsnog moet trianguleren, of op een ingewikkelde manier zou willen renderen?

Weet je zeker dat dat bestand op de juiste manier uitleest?

[Verwijderd]

Da's mooi

Hier is het testbestand dat ik gebruik om het inlezen te testen:

http://www.netforge.nl/rommel/Drtrans.PIE

De Points sectie spreek voor zich, dat zijn gewoon de vertices. Maar de Polygon sectie ben ik nog niet helemaal uit. Tot nu toe heb ik het zo ontleed:

Line: 4200 4 27 26 25 24 8 1 18 14 107 42 125 42 125 56 107 56

Pos:   1   2  3  4  5  6 7 8  9  10 ..    

1. Een of andere type code 
      200 lijkt te staan voor een 'single sided' normale triangle
     4200 'single-sided' polygon
     6a00 'double-sided' polygon (dus zonder backface culling)

2. Aantal indices (n)

3....3 + n zijn de indices

De rest zullen wel normal data en texture coordinates zijn, maar ik ben momenteel al blij met de geometrie!

Ik heb de PIE slicer al gebruikt om enkele triangles en polygons te maken om te testen. Bij enkele figuren ziet het er goed uit, alleen ben ik nog niet bepaald zeker van de 'winding order'. De PIE slicer is bij mij trouwens erg buggy, crasht regelmatig en produceert '0' type polygons die er niet horen te zijn. Enfin, ik heb geprobeerd contact op te nemen met de maker van de PIE slicer, maar z'n hotmail mailbox bestaat niet meer.

Dat de broncode voor WZ2100 uit is was voor mij de reden om hier mijn 3D avontuur te beginnen. Ik loop al een hele tijd rond met het idee om een RTS te maken en ik ben al sinds jaar en dag fan van WZ2100, dus ik wou een poging ondernemen om WZ2100 te recreeren in Managed DirectX / C#. Een hele RTS is natuurlijk wel wat optimistisch voor een enkele beginnende 3D hobbyist, maar je moet ergens beginnen he

Ik ga zowiezo eens neuzen in de broncode van WZ2100 om te kijken of ik daar wat vind, maar als je eens naar het bestand wilt kijken om te zien of je er wat van kunt maken, dan hoor ik het graag.

ps. het begin

[Verwijderd]

Ik moet echt sneller leren typen, ik was aan het replyen op de eerste reply van CodeCaster

Culling staat al uit en voor zover ik heb gezien zijn alle polies convex, dus zou m'n functie moeten werken. Ik geef alle indices van de Polygon mee aan m'n function en als het goed is komt er een array met triangles op basis van de indices terug, toch?

Ik zie niet in waarom men modellen voor een spel zodanig zou willen opslaan, dat men ze na het inladen alsnog moet trianguleren, of op een ingewikkelde manier zou willen renderen?

Weet je zeker dat dat bestand op de juiste manier uitleest?

Yep, ik heb met de PIE slicer verschillende Polygonen geteken en deze worden idd zo opgeslagen. Vergeet niet dat het spel uit 1999 is. Toen bestond volgens mij ook nog hardware ondersteuning voor het renderen van hogere graads polygonen en met de low-poly modellen van wz2100 zal het vrij weinig hebben uitgemaakt... denk ik dan...

[Verwijderd]

En nog even voor de volledigheid, hier wat screenshots van de geladen modellen:


1. Een enkele triangle


2. Een polygon (5 vertices, 3 triangles)


3. Het transporter model uit wz2100


Het lijkt wel of er een paar vertices niet kloppen, want terwijl het model ronddraait verschijnen er soms rare triangles naar een punt ver buiten het scherm... Kan dit aan de winding order liggen of zit er iets anders goed mis?

Alweer bedankt in ieder geval

[CodeCaster]

Als er rare polygoon errors verschijnen kan het zijn dat je index- of vertexbuffer te groot is.

Als je een indexbuffer maakt voor 5x16-bit indices en je zet er maar 3 in, crasht VB (ik gebruik VB6 en DirectX8) óf er verschijnen vertices die buiten het scherm ligt.

Kun je dit controleren? Ik ga zo denk ook ff zo'n PIE renderer bouwen! Interessant bestandsformaat...

[Verwijderd]

Bij Managed DirectX 9 op C# krijg je in zo'n geval een EngineExecutionException (wat je officieel NOOIT zou moeten krijgen volgens de docs...) als je buffer te groot is en een StackOverFlowException als je buffer te klein is. Niet dat ik dat zelf ooit heb meegemaakt met mijn code natuurlijk...

Het is inderdaad een heel interessant bestandsformaat, vooral met die connectors waarmee ze verschillende meshes aan elkaar koppelen. Misschien is dit al een veelgebruikte techniek tegenwoordig (iets soortgelijks zit ook in Neverwinter Nights), maar voor het bouwen van RTS units vind ik het een geweldige vinding... en dat voor een spel uit 1999!

Ik wou het eigenlijk helemaal zelf maken, maar ik ben wel geinteresseerd in de source van je viewer als je hem af krijgt. Vooral texturing via die PCX pages lijkt me vrij moeilijk zelf te doen voor een beginner als ik

[CodeCaster]

Ik kan vanavond pas beginnnen met coden, redelijk druk op stage

Ik vond wel dit in de sourcecode van t spel, mss heb je er iets aan:

code:

// Expanded PIEVERTEX.
typedef struct {
    // PIEVERTEX.
    SDWORD sx, sy, sz; UWORD tu, tv; PIELIGHT light, specular;
    // Extra data for water.
    SDWORD wx, wy, wz; PIELIGHT wlight;
    UBYTE   drawInfo;
    UBYTE   bWater;
} SVMESH;

En dit:

code:

if (nVerts == 3)//triangle
    {
        hResult = g_sD3DGlob.psD3DDevice3->lpVtbl->DrawPrimitive(
                    g_sD3DGlob.psD3DDevice3,
                    D3DPT_TRIANGLEFAN,
                    D3DFVF_TLVERTEX,
                    (LPVOID)psVert,
                    nVerts,
                    CLIP_STATUS );
    }
    else if (nVerts > 3)//poly
    {
        hResult = g_sD3DGlob.psD3DDevice3->lpVtbl->DrawPrimitive(
                    g_sD3DGlob.psD3DDevice3,
                    D3DPT_TRIANGLEFAN,
                    D3DFVF_TLVERTEX,
                    (LPVOID)psVert,
                    nVerts,
                    CLIP_STATUS );
    }

Hopelijk kun je nu wat verder

[Verwijderd]

Hey, wacht eens ff... dus zij tekenen ook de polygonen stuk voor stuk met een TriangleFan

[CodeCaster]

Ja Ik kon alleen het stukje waar ze een PIE bestand laden niet vinden... man, wat een hoop code... Ik zoek nog ff door voor je.

[Verwijderd]

Ok, ik zit weer ff met een stomme vraag vast... ik heb de vertex- en indexbuffers even overboord gegooid om te leren hoe het nu precies achter de schermen werkt. Hiervoor heb ik m'n eigen array van vertices aangelegd en een int[][] van polygonen. Zo zou ik elke polygon stuk voor stuk moeten kunnen tekenen met device.DrawUserPrimitives(type, numPrimitives, vertices), dus zo:

code:

   class PieMesh
   {
       // code om deze arrays te vullen heb ik weggelaten, maar uit debug prints 
       // blijkt dat wel correct gebeurd.

        CustomVertex.PositionColored[] verts = null;
        int[][] polies;


        public void Render(Device device)
        {
            for(int i = 0; i < polies.Length; i++)
            {
                int[] polygon = polies[i];
                CustomVertex.PositionColored[] vertices = verticesForPolygon(polygon);
                device.DrawUserPrimitives( PrimitiveType.TriangleFan, 1, vertices );            
            }
        }

        private CustomVertex.PositionColored[] verticesForPolygon( int[] polygon )
        {
            CustomVertex.PositionColored[] vertices = new CustomVertex.PositionColored[polygon.Length];

            for(int i = 0; i < polygon.Length; i++)
            {
                vertices[i] = verts[polygon[i]];
            }

            return vertices;
        }
    }

Alleen... het werkt niet. Hij lijkt alleen de laatste primitive te tekenen van de polygon. Zo tekent hij met een TriangleFan de laatste triangle, met LineStrip de laatste lijn van de polygon en met PointList het laatste punt van de Polygon... schijnbaar doe ik iets flink fout... alleen ik zie zo langzamerhand niet meer waar... iemand enig idee?

[CodeCaster]

Bij DX8+VB heb ik de keuze uit:

code:

.DrawIndexedPrimitiveUP
.DrawPrimitiveUP
.DrawIndexedPrimitive
.DrawPrimitive

Gebruik je wel de juiste functie hiervoor?

[Verwijderd]

Yep, ik ben eruit... de numPrimitives parameter staat schijnbaar voor het aantal triangles/lines/points dat getekend moet worden. Dus moet ik als numPrimitives het aantal vertices - 2 opgeven voor een TriangleFan (logisch en goed gedocumenteerd zoals de rest van de managed API )... maar goed



Nu alleen nog backface culling en Z-buffering... kan ik de CullMode trouwens tussen het renderen van 2 primitives veranderen? In WZ2100 zijn er speciale polygons waarbij er geen backface culling moet plaatsvinden, dus...

En Z-buffering moet ik me nog in gaan verdiepen, maar is dit eigenlijk wel mogelijk in de Managed API zonder vertex- en indexbuffers? Ik heb dit eens aangezet (via AutoDepthStensil op D16) zonder er verder wat van af te weten maar dat ging dus goed mis...

[CodeCaster]

Z-Buffering wordt gedaan middels een depth-stencil, hier weet ik niks van

Ik ben nu ook bezig met een renderer, hij werkt nog niet, zometeen een update.

[.oisyn]

Wat veel reacties weer, waarom komen dit soort topics altijd als ik er niet ben Zit in california voor m'n werk, om te praten over onze nieuwe 3d engine

Verwijderd schreef op donderdag 24 maart 2005 @ 09:15:
monotone ( en dus convex? )

Min of meer. Monotoon in een bepaalde richting wil zeggen dat, als je bij de minimale vertex in die richting begint en verder loopt, je nooit edges krijgt die in de tegengestelde richting gaan. Monotoon in alle richtingen betekent dan idd dat ze convex zijn .

Verwijderd schreef op donderdag 24 maart 2005 @ 16:55:
Yep, ik ben eruit... de numPrimitives parameter staat schijnbaar voor het aantal triangles/lines/points dat getekend moet worden. Dus moet ik als numPrimitives het aantal vertices - 2 opgeven voor een TriangleFan (logisch en goed gedocumenteerd zoals de rest van de managed API )... maar goed

[afbeelding]

Nu alleen nog backface culling en Z-buffering... kan ik de CullMode trouwens tussen het renderen van 2 primitives veranderen? In WZ2100 zijn er speciale polygons waarbij er geen backface culling moet plaatsvinden, dus...

Uiteraard, ik zou het alleen niet zomaar doen . Als je de polygonen sorteert op culling mode, hoef je de culling setting maar 1 keer te veranderen per mesh. Of je maakt de poly's echt doublesided, dus 2 polygonen in beide richtingen (de andere richting kun je natuurlijk krijgen door de indices in de omgekeerde volgorde te definieren), dan hoef je niet eens de cullmode te veranderen.

En Z-buffering moet ik me nog in gaan verdiepen, maar is dit eigenlijk wel mogelijk in de Managed API zonder vertex- en indexbuffers? Ik heb dit eens aangezet (via AutoDepthStensil op D16) zonder er verder wat van af te weten maar dat ging dus goed mis...

Z-buffering heeft niets te maken met vertex of index buffers. En zelfs met de user arrays worden de buffers alsnog aangemaakt, simpelweg omdat dat de enige manier is om de vertices naar je videokaart te sturen . Het geeft natuurlijk wel wat extra overhead, dus ik zou ze in een productieomgeving niet gebruiken, maar voor de z-buffering maakt het niets uit.

[CodeCaster]

Ik heb zelf ook even een PIE renderer gebouwd



En



Het renderen doe ik zo (tis VB maar de DirectX functies lijken me duidelijk) :

code:

Public Sub Render()

    Dim i       As Long
    Dim mat0    As D3DMATRIX
    
    D3DXMatrixIdentity mat0
    

    With g_D3DDevice
    
        .SetTransform D3DTS_WORLD, mat0
        .SetVertexShader Block_Vertex_Shader_Fixed_Function
        .SetStreamSource 0, g_VB, Len(Vertex(0))
        
        For i = 0 To lNumPolygons - 1
            .SetIndices Polygon(i).g_IB, 0
            If Polygon(i).lNumIndices = 4 Then
                .DrawIndexedPrimitive D3DPT_TRIANGLEFAN, 0, lNumVertices, 0, 2
            ElseIf Polygon(i).lNumIndices = 3 Then
                .DrawIndexedPrimitive D3DPT_TRIANGLELIST, 0, lNumVertices, 0, 1
            End If
        Next i
    End With

End Sub

En het laden:

code:

Public Sub LoadFromFile(strFileName As String)

    Dim lFID        As Long
    Dim strTemp     As String
    Dim strSplit()  As String
    Dim i           As Long
    Dim j           As Long
        
    ' Get a free file handle (usually #1)
    lFID = FreeFile()
    
    Open strFileName For Input As #lFID
    
        Line Input #lFID, strTemp   ' PIE 2
        Line Input #lFID, strTemp   ' TYPE 200
        Line Input #lFID, strTemp   ' TEXTURE 0 Page-12-Player Buildings.pcx 256 256
        Line Input #lFID, strTemp   ' LEVELS 1
        Line Input #lFID, strTemp   ' LEVEL 1
        Line Input #lFID, strTemp   ' POINTS 32
    
        strSplit = Split(strTemp, " ")
        lNumVertices = CLng(strSplit(1))
        
        ReDim Vertex(lNumVertices - 1)
        
        Debug.Print "Number of vertices: " & lNumVertices
    
        For i = 0 To lNumVertices - 1
            Line Input #lFID, strTemp
            strSplit = Split(FixString(strTemp), " ")
            
            With Vertex(i)
                .pos.x = CSng(strSplit(0))
                .pos.y = CSng(strSplit(1))
                .pos.z = CSng(strSplit(2))
            
                D3DXVec3Normalize .n, .pos
            End With
        Next i
    
        Line Input #lFID, strTemp   ' POLYGONS 8
        strSplit = Split(strTemp, " ")
        
        lNumPolygons = CLng(strSplit(1))
        ReDim Polygon(lNumPolygons - 1)
        Debug.Print "Number of polygons: " & lNumPolygons
        
        For i = 0 To lNumPolygons - 1
            Line Input #lFID, strTemp
            strSplit = Split(FixString(strTemp), " ")
            
            With Polygon(i)
                .type = strSplit(0)
                .lNumIndices = Val(strSplit(1))
                ReDim .Index(.lNumIndices - 1)
                For j = 0 To .lNumIndices - 1
                    .Index(j) = CInt(strSplit(2 + j))
                Next j
            End With
        Next i
    
    Close #lFID

    CreateBuffers

End Sub

Buffers maken:

code:

Public Sub CreateBuffers()

    Dim i   As Long

    ' Create buffers from the polygons
    Set g_VB = g_D3DDevice.CreateVertexBuffer(Len(Vertex(0)) * lNumVertices, 0, Block_Vertex_Shader_Fixed_Function, D3DPOOL_DEFAULT)
    D3DVertexBuffer8SetData g_VB, 0, Len(Vertex(0)) * lNumVertices, 0, Vertex(0)

    For i = 0 To lNumPolygons - 1
        With Polygon(i)
            Set .g_IB = g_D3DDevice.CreateIndexBuffer(Len(.Index(0)) * .lNumIndices, 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT)
            D3DIndexBuffer8SetData .g_IB, 0, Len(.Index(0)) * .lNumIndices, 0, .Index(0)
        End With
    Next i

End Sub

Jouw renderer werkt al, maar misschien zie je nog iets handigs tussen de code.

Thanks to ImageShack for Free Image Hosting

[Verwijderd]

Ik denk dat ik uit jouw code nog wel de nodige interessante stukken kan halen, vooral omdat mijn renderer nu werkt zonder (expliciete) vertex- en indexbuffers Bedankt voor de hulp in ieder geval!

Zit in california voor m'n werk, om te praten over onze nieuwe 3d engine

Die van SnowBlind? Met hoeveel man hebben jullie eigenlijk nou aan het project gewerkt? Ben gewoon even nieuwsgierig hoe de spelletjesindustrie nou achter de schermen werkt... Dus als je wat kwijt wilt over het project dan spam gerust maar raak

[Verwijderd]

Nog even een update... ik ben bezig met de PIE nu in te laden in een Mesh object en daarvoor moest ik de polygonen toch trianguleren. In de code die ik hierboven heb gepost zat toch een fout, dus als iemand nog een keer een simpele triangulation functie zoekt is dit de goede versie:

code:

public static int[][] TriangulatePolygon( int[] polyIndices )
{           
    int triangleCount = polyIndices.Length - 2;
    int[][] triangles = new int[triangleCount][];

    for(int i = 0; i < triangleCount; i++)
    {
        triangles[i] = new int[] { polyIndices[0], polyIndices[i + 1], polyIndices[i + 2] };
    }

    return triangles;
}

[.oisyn]

Verwijderd schreef op vrijdag 25 maart 2005 @ 09:34:
Die van SnowBlind?

Nee, die is al gereleased, en waar we nu aan werken kan/mag ik nog weinig over zeggen, maar het is ook meer gewoon "de next-gen engine" die in de toekomstige spellen gebruikt gaat worden. Wat aantal teamleden betreft zou ik eigenlijk niet weten, we zijn bij Nixxes met 10 man, maar we werken samen met andere bedrijven die echt voor de game en de content zorgen, wij doen in principe alleen maar tech en tools (en wat porting zut). Maar gisteren was er een meeting van het volledige tomb raider 7 team, en daar waren toch wel een man of 40 oid. Maar dat is Crystal Dynamics, het zegt eigenlijk weinig... ik weet van EA dat zij soms wel 200 man op een project hebben zitten, en Engine Software in Nederland heeft slechts een stuk of 10 werknemers, dus het verschil nogal (uiteraard ook afhankelijk van de grootte van het project).

[Verwijderd]

Bedankt voor de info. Ik was, zoals ik al zei, gewoon nieuwsgierig hoeveel werk het nu eigenlijk is om een beetje een 3D spel te programmeren en hoeveel man er nu voor nodig zijn. Ik ben zelf van plan om een RTS te proberen te schrijven, gebaseerd op het concept van Warzone 2100. Misschien wat ambitieus als 3D beginner, maar ik heb de tijd en je moet toch ergens beginnen In ieder geval hoef ik niet alle content nog zelf te maken, want ik had al zo'n vermoeden dat daar misschien wel het meeste werk in zou gaan zitten.

Maar goed, dan moet ik dus eerst wel nog wat meer gaan leren over 3D spul, want ik zit alweer vast en volgens mij op een heel basis onderdeel. Ik kan nu m'n PIE bestand inladen als een D3D Mesh, met de goede culling en met alleen triangles als polygonen, maar ik zit nog met een probleem met de textures.

In het PIE bestand staan achter de polygonen een aantal cijfers die volgens mij de uv coordinaten per vertex in de polgoon voorstellen. Ook al heb ik geen flauw idee hoe dit werkt (Tom Miller's boek over game programming krijg ik volgende week pas ), ik wou toch uitproberen om het aan het werkt te krijgen, alleen ik weet niet hoe...

De UV coordinaten moeten schijnbaar geset worden op een PositionNormalTextured vertex, maar omdat de textures per polygon gespecifeerd zijn weet ik niet hoe ik dit nu moet aanpakken. Moet ik nu nieuwe vertices aanmaken voor de verschillende polygonen waarin ze gebruikt worden? Zo ja, wat is dan nog het nut van de indexbuffer/vertextbuffer aanpak? En zo nee, hoe moet het dan?

Ik heb al wat rondgeneusd, maar zelf texturen doen schijnbaar maar weinig mensen in D3D en in m'n boeken kan ik ook maar bitter weinig hierover terugvinden, dus als iemand hier weer even z'n licht op wilt laten schijnen, dan hoor ik het graag. Ook introductie turorials over UV mapping en texturing in het algemeen zijn ERG welkom.

Alweer bedankt!

[ Voor 5% gewijzigd door Verwijderd op 28-03-2005 00:12 ]

[CodeCaster]

http://msdn.microsoft.com...es/TextureCoordinates.asp

Misschien heb je hier iets aan, of is dat té basic? IIG zijn die gegevens in het PIE bestand achter de polygonen niet echt bepaald correcte tu en tv waarden. Maar dat moet je zelf maar even uitzoeken, met bovenstaande link (en de drie links onderaan de pagina) kom je er wel uit, denk ik.

[ Voor 5% gewijzigd door CodeCaster op 30-03-2005 14:40 ]