Imports Microsoft.Xna.Framework
Imports Microsoft.Xna.Framework.Input
Imports Microsoft.Xna.Framework.Graphics

Public Class Game
    Inherits Microsoft.Xna.Framework.Game

    'Cominciamo a dividere il sorgente in sezioni, per
    'renderlo più ordinato. Alla fine di questo
    'tutorial mi ringrazierete, perchè ci sarà
    'un bel po' di codice.
    'Usiamo lo statement #Region, che non ho spiegato nella
    'guida sul Vb.Net. È molto semplice:
    '#Region "Nome regione"
    '   'codice
    '#End Region
    'Non ha alcuna funzione dinamica: serve solo per rendere
    'il codice più ordinato

#Region "Variabili globali"

    Private AppPath As String = _
        My.Application.Info.DirectoryPath

    Private Graphics As GraphicsDeviceManager

    Private Shader As Effect
    Private Vertices(5) As VertexPositionColor
    Private Indices(11) As Int32
    Private VDeclaration As VertexDeclaration

    Private ViewMatrix As Matrix
    Private ProjectionMatrix As Matrix
    Private WorldMatrix As Matrix

    Private DX, DZ As Single
    Private Angle As Single

    'La variabile HeightData è un array a 
    'due dimensioni, che a due coordinate x e z
    'fa corrispondere una coordinata y. Ad esempio
    'HeightData(1, 2) restituirà l'altezza y
    'del vertice di coordinate x = 1, z = -2
    '(ricordate sempre che z è invertito)
    Private HeightData(,) As Single
    'Definiamo qui come costanti l'altezza minima
    'e massima raggiungibili da un vertice. Dato
    'che la componente R di un colore può
    'andare da 0 a 255, certo non vorremmo che un
    'vertice abbia altezza 255, altrimenti il
    'terreno sarebbe enormemente deformato verso
    'l'alto!
    Private Const MinHeight As Single = 0
    Private Const MaxHeight As Single = 30
    'Queste variabili assumeranno il valore di
    'larghezza e lunghezza del terreno
    Private TerrainWidth, TerrainLength As Int32
#End Region

#Region "Funzioni utili"

    Private Function GetEffect(ByVal FileName As String) As Effect
        Dim CompEffect As CompiledEffect = _
            Effect.CompileEffectFromFile(FileName, _
            Nothing, Nothing, _
            CompilerOptions.None, _
            TargetPlatform.Windows)

        Return New Effect(Me.GraphicsDevice, _
            CompEffect.GetEffectCode, _
            CompilerOptions.None, Nothing)
    End Function

    'Ridefiniamo la cara funzione GetTexture, già usata
    'nel tutorial sul 2D
    Private Function GetTexture(ByVal FileName As String)
        Return Texture2D.FromFile(Me.GraphicsDevice, FileName)
    End Function

#End Region

#Region "Caricamento Heightmap"
    'Carica l'array HeightData
    Private Sub LoadHeightMap(ByVal HeightMap As Texture2D)
        'Imposta le dimensioni del terreno
        TerrainWidth = HeightMap.Width
        TerrainLength = HeightMap.Height '2D!

        'Crea un array tabulare per contenere i colori
        'di ogni pixel dell'heightmap
        Dim Colors(TerrainWidth * TerrainLength - 1) As Color
        'Riempie l'array prelevando i colori dall'immagine
        HeightMap.GetData(Colors)

        'Ridimensiona HeightData.
        'Ricordate che ReDim ha un effetto particolare 
        'sugli array a due dimensioni. Infatti,
        'bisogna ridimensionare ogni singola dimensione
        'dell'array. Per rinfrescarvi la memoria,
        'guardate il capitolo sugli array nella guida
        For I As Int32 = 0 To TerrainWidth - 1
            ReDim HeightData(I, TerrainLength - 1)
        Next

        For X As Int32 = 0 To TerrainWidth - 1
            For Z As Int32 = 0 To TerrainLength - 1
                'Vedi Nota 1 per la spiegazione di questo calcolo
                HeightData(X, Z) = MinHeight + _
                    (Colors(X + Z * TerrainWidth).R / 255) * _
                    (MaxHeight - MinHeight)
            Next
        Next

        VDeclaration = New VertexDeclaration(Me.GraphicsDevice, _
            VertexPositionColor.VertexElements)
    End Sub

    'Ora che abbiamo la dimensione del terreno e l'altezza di
    'ogni vertice, popoliamo l'array Vertices
    Private Sub SetVertices()
        'Consideriamo Vertices come un array tabulare
        ReDim Vertices(TerrainWidth * TerrainLength - 1)

        For X As Int32 = 0 To TerrainWidth - 1
            For Z As Int32 = 0 To TerrainLength - 1
                With Vertices(X + Z * TerrainWidth)
                    'Impostiamo la posizione
                    .Position = New Vector3(X, HeightData(X, Z), -Z)
                    'E il colore
                    .Color = Color.White
                End With
            Next
        Next
    End Sub

    'Questo metodo è più complesso di prima,
    'quindi fate attenzione
    Private Sub SetIndices()
        'Vedi Nota 2 per la spiegazione di questo codice
        ReDim Indices((TerrainWidth - 1) * (TerrainLength - 1) * 6 - 1)

        'Noi stiamo leggendo una tabella, ma Indices
        'è un array a una dimensione, quindi ci
        'serve un contatore per impostarne i valori
        Dim Counter As Int32 = 0

        For X As Int32 = 0 To TerrainWidth - 2
            For Z As Int32 = 0 To TerrainLength - 2
                'Questi valori rappresentano delle coordinate
                'nell'array tabulare Vertices. Infatti,
                'ogni quattro pixel nell'immagine, si hanno
                'quattro vertici, perciò due triangoli
                'e quindi 6 indici. È un po' confusionario,
                'lo so, ma fateci l'abitudine.

                'Vertice inferiore sinistro
                Dim LowerLeft As Int16 = X + Z * TerrainWidth
                'Vertice inferiore destro
                Dim LowerRight As Int16 = (X + 1) + Z * TerrainWidth
                'Vertice superiore sinistro
                Dim TopLeft As Int16 = X + (Z + 1) * TerrainWidth
                'Vertice superiore destro
                Dim TopRight As Int16 = (X + 1) + (Z + 1) * TerrainWidth

                'Ricordate che le coordinate X e Z sono prese da
                'un'immagine a due dimensioni. Perciò
                'leggendo l'immagine dall'alto verso il basso, la
                'coordinata y dei pixel aumenta

                'Primo triangolo, formato, in ordine, dai vertici:
                '- Superiore sinistro
                '- Inferiore destro
                '- Inferiore sinistro
                Indices(Counter) = TopLeft
                Indices(Counter + 1) = LowerRight
                Indices(Counter + 2) = LowerLeft
                Counter += 3

                'Secondo triangolo, formato, in ordine, dai vertici:
                '- Superiore sinistro
                '- Superiore destro
                '- Inferiore destro
                Indices(Counter) = TopLeft
                Indices(Counter + 1) = TopRight
                Indices(Counter + 2) = LowerRight
                Counter += 3
            Next
        Next
    End Sub
#End Region

#Region "Gestione risorse"

    Sub New()
        Me.Graphics = New GraphicsDeviceManager(Me)
        Me.Content.RootDirectory = "content"
    End Sub

    Protected Overrides Sub Initialize()
        MyBase.Initialize()
    End Sub

    Protected Overrides Sub LoadContent()
        Shader = GetEffect(AppPath & "\SimpleShader.fx")
        'Carica la HeightMap
        LoadHeightMap(GetTexture(AppPath & "\HeightMap.bmp"))
        'Imposta i vertici
        SetVertices()
        'Imposta gli indici
        SetIndices()

        'Spostiamo la telecamera molto in fuori, poiché
        'il terreno sarà piuttosto grande
        ViewMatrix = Matrix.CreateLookAt( _
            New Vector3(70, 100, -70), _
            New Vector3(0, 0, 0), _
            New Vector3(0, 1, 0))

        ProjectionMatrix = Matrix.CreatePerspectiveFieldOfView( _
            MathHelper.PiOver4, _
            Me.GraphicsDevice.Viewport.AspectRatio, _
            1, 500)

        MyBase.LoadContent()
    End Sub

    Protected Overrides Sub UnloadContent()
        MyBase.UnloadContent()
    End Sub

#End Region

#Region "Aggiornamento mondo 3D"
    Protected Overrides Sub Update(ByVal GameTime As GameTime)
        'Facciamo sì che il terreno ruoti, per poterlo
        'ammirare da ogni angolazione
        Angle += MathHelper.Pi / 600
        MyBase.Update(GameTime)
    End Sub

    Protected Overrides Sub Draw(ByVal gameTime As GameTime)
        Me.Graphics.GraphicsDevice.Clear(Color.CornflowerBlue)

        Shader.CurrentTechnique = Shader.Techniques("Colored")

        Shader.Parameters("View").SetValue(ViewMatrix)
        Shader.Parameters("Projection").SetValue(ProjectionMatrix)
        'Trasliamo il mondo in modo che tutto il terreno sia
        'al centro del nostro sguardo, puoi ruotiamolo
        Shader.Parameters("World").SetValue( _
            Matrix.CreateTranslation( _
            New Vector3(-TerrainWidth / 2, 0, TerrainLength / 2)) * _
            Matrix.CreateRotationY(Angle))

        Me.GraphicsDevice.RenderState.FillMode = FillMode.WireFrame

        Shader.Begin()
        For Each Pass As EffectPass In Shader.CurrentTechnique.Passes
            Pass.Begin()
            With Me.GraphicsDevice
                .VertexDeclaration = VDeclaration
                .DrawUserIndexedPrimitives(PrimitiveType.TriangleList, _
                    Vertices, 0, Vertices.Length, _
                    Indices, 0, Indices.Length / 3)
            End With
            Pass.End()
        Next
        Shader.End()

        MyBase.Draw(gameTime)
    End Sub
#End Region
End Class 

• Nota 1
  

  HeightData(X, Z) = MinHeight + _ 
      (Colors(X + Z * TerrainWidth).R / 255) * _ 
      (MaxHeight - MinHeight) 

  Come abbiamo detto prima, non vogliamo che i nostri vertici possano avere un'altezza che raggiunga le 255 unità, perchè, altrimenti, il terreno risulterebbe enormemente deformato. I valori che abbiamo stabilito prevedono un'altezza minima di 0 (ossia i vertici più in basso avranno coordinata y = 0) e una massima di 30 (ossia i vertici più in alto avranno una coordinata y = 30). Allora, consideriamo la componente R come se rappresentasse una percentuale: 255 significa 100% di altezza (ossia 30 unità), mentre 0 significa 0% (ossia 0 unità). Calcoliamo la percentuale con una proporzione:
  

  R : 255 = x : 100
  x = 100 * R / 255 

  x è la nostra percentuale, la mettiamo da parte un attimo. Dato che l'altezza minima del vertice è MinHeight, aggiungiamo subito questo valore alla sua altezza:
  

  Y = MinHeight 

  Allora, se vogliamo ottenere l'altezza massima dobbiamo aggiungere alla minima la loro differenza:
  

  Ymax = MinHeight + (MaxHeight - MinHeight) 

  Per ottenere le altezze intermedie, non dobbiamo aggiungere tutta la differenza (MaxHeight - MinHeight), ma solo una sua parte, definita dalla percentuale x, allora arriviamo a questo rislutato:
  

  Y = MinHeight + (x / 100) * (MaxHeight - MinHeight) 

  Svolgiamo il termine x:
  

  Y = MinHeight + ((R * 100 / 255) / 100) * (MaxHeight - MinHeight) 

  Dove R * 100 / 100 = R. Sostituendo le variabili opportune arriviamo a:
  

  HeightData(X, Z) = MinHeight + _ 
      (Colors(X + Z * TerrainWidth).R / 255) * _ 
      (MaxHeight - MinHeight) 

• Nota 2
  Intanto iniziamo a spiegare questa linea:
  

  ReDim Indices((TerrainWidth - 1) * (TerrainLength - 1) * 6 - 1) 

  Ormai sappiamo che il "-1" finale è onnipresente nella definizione di un array, quindi lo do per scontato. Quello che bisogna spiegare sono i -1 nelle parentesi e il fattore 6. Guardiamo questo disegno, dove i pallini neri sono vertici:
  
  
  Sorvoliamo sulla precisione...
  
  Ci sono 5 vertici in orizzontale e 3 in verticale. Tuttavia ogni riga contiene 4 (e non 5) triangoli, e ogni colonna contiene 2 (e non 3) triangoli. La conclusion logica è che in una tabella larga X vertici e alta Y vertici, ci saranno X-1 triangoli per ogni riga e Y-1 triangoli per ogni colonna. Ecco la motivazione di quei -1.
  Per quanto riguarda il 6, il discorso è molto più semplice. Dato che ogni vertice fa parte di due triangoli, saranno necessari 6 indici per disegnarli tutti e due (potete controllare nell'immagine sopra).
  Ora, immaginate che ogni vertice dell'immagine sopra sia un pixel della nostra Height Map. È evidente che per ogni quattro pixel, ci sono due triangoli, il primo formato dai pixel superiore sinistro, inferiore destro e inferiore sinistro; il secondo definito dai pixel inferiore destro, superiore sinistro, superiore destro. E così si spiega anche il pezzo di codice dentro il for.
• Nota 3:
  Se non sapete cos'è un array tabulare, guardate la sezione appunti

Il codice completo c'è già qua sopra