Ordinamento alfabetico di un array

Funzione che individua una casella "compagna"

Devo inventare una funzione che, se la mia label ha il tag "mattina" e se nell'altra il tag sia uguale e abbia un testo corrispondente a un menu, questo menu non venga caricato nel menu popup.

Se una casella con lo stesso numero di riga e con lo stesso tag ha un certo testo non caricare il menu con questo testo.
Una funzione dovrebbe individuare la casella "compagna" sulla base del criterio che è o precedente o seguente e ha lo stesso tag.

Proviamo a buttare giù qualcosa del genere...

    Function compagna(ByVal sender As Object) As Label
        If precedente(sender).Tag = sender.tag Then
            Return precedente(sender)
        ElseIf successiva(sender).Tag = sender.tag Then
            Return successiva(sender)
        Else
            Return Nothing
        End If
    End Function

Ecco.
Ovviamente, la funzione può restituire un Nothing, per cui può essere sollevata un'eccezione: per questo motivo va gestita l'eccezione con un codice Try... Catch.

    Sub ClassEventHandler(ByVal sender As Object, ByVal e As MouseEventArgs) Handles miaGriglia.Evento
        Try
            compagna(sender).BackColor = Color.Green
        Catch ex As Exception

        End Try

    End Sub

E, premesso questo, funziona.

Ricostruzione codice perso inavvertitamente: menu popup al calendario.

Menu popup al calendario

Input/Output su un file modalità Random

Scrittura di un file con IO.StreamWriter

Aggiunta di sottomenu a un menu popup a runtime

Studio dei menu

Evento nei vari elementi di un ArrayList

Ecco il codice per gestire un evento in tutti gli elementi di un ArrayList:

Public Class Form1
    Dim matrice As ArrayList
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        matrice = New ArrayList
        matrice.Add(TextBox1)
        matrice.Add(TextBox2)
        matrice.Add(TextBox3)
        For Each elemento As TextBox In matrice
            AddHandler elemento.Click, AddressOf evento
        Next
    End Sub
    Sub evento(ByVal sender As Object, ByVal e As EventArgs)
        MsgBox("Ciao")
    End Sub
End Class

Calendario/griglia riposizionabile.

Ho anche aggiunto del codice per evidenziare i sabati e le domeniche:

        For n = 0 To mioCalendario.Count - 1
            If Weekday(mioCalendario(n).text) = 1 Then mioCalendario(n).forecolor = Color.Red
            If Weekday(mioCalendario(n).text) = 7 Then mioCalendario(n).forecolor = Color.Blue
        Next

Questo è possibile, ovviamente, in virtù del fatto che la classe Calendario eredita da ArrayList, discorso che avevo già fatto prima.

Classe Calendario erede di ArrayList (per interagire con le caselle)

Classe Calendario (un calendario flessibile)

Creazione di un calendario

Classe label personalizzata per mezzo dell'ereditarietà

Griglia come erede di ArrayList per interagire con i suoi elementi

Orientamento orizzontale o verticale di una griglia di labels

Creazione di una classe Griglia di labels.

Ripasso delle date in VB.NET

Interazione con specifiche labels della griglia creata.

Appunti video sulla creazione di una griglia di labels.

Mi è venuto in mente un mezzo innovativo per i miei appunti: i video!

Costruzione di un quadrato con due triangoli.

Bene.
Ora cerchiamo di disegnare un quadrato fatto di due triangoli.

Pagina di riferimento per il costruttore di VertexBuffer

Ecco il codice:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        NumeroVertici = 4
        NumeroIndici = 4

        InitializeGraphics()
        VBuffer = New VertexBuffer(GetType(CustomVertex.PositionColored), NumeroVertici, dispositivo, 0, CustomVertex.PositionColored.Format, Pool.Default)
        Dim vertici As CustomVertex.PositionColored() = New CustomVertex.PositionColored(NumeroVertici) {}
        vertici(0).Position = New Vector3(0, 0, 0)
        vertici(0).Color = Color.Blue.ToArgb
        vertici(1).Position = New Vector3(5, 0, 0)
        vertici(1).Color = Color.Red.ToArgb
        vertici(2).Position = New Vector3(5, 5, 0)
        vertici(2).Color = Color.Yellow.ToArgb
        vertici(3).Position = New Vector3(0, 5, 0)
        vertici(3).Color = Color.Green.ToArgb
       

        VBuffer.SetData(vertici, 0, LockFlags.None)




        ib = New IndexBuffer(GetType(Integer), NumeroIndici, dispositivo, 0, Pool.Default)
        Dim indici As Integer() = New Integer(NumeroIndici) {}
        indici(0) = 1
        indici(1) = 2
        indici(2) = 0
        indici(3) = 3
        'indici(4) = 2
        'indici(5) = 0
        ib.SetData(indici, 0, LockFlags.None)

...

Prima si costruisce il VertexBuffer:

        VBuffer = New VertexBuffer(GetType(CustomVertex.PositionColored), NumeroVertici, dispositivo, 0, CustomVertex.PositionColored.Format, Pool.Default)
        Dim vertici As CustomVertex.PositionColored() = New CustomVertex.PositionColored(NumeroVertici) {}
        vertici(0).Position = New Vector3(0, 0, 0)
        vertici(0).Color = Color.Blue.ToArgb
        vertici(1).Position = New Vector3(5, 0, 0)
        vertici(1).Color = Color.Red.ToArgb
        vertici(2).Position = New Vector3(5, 5, 0)
        vertici(2).Color = Color.Yellow.ToArgb
        vertici(3).Position = New Vector3(0, 5, 0)
        vertici(3).Color = Color.Green.ToArgb
       

        VBuffer.SetData(vertici, 0, LockFlags.None)

Quindi l'IndexBuffer:

        ib = New IndexBuffer(GetType(Integer), NumeroIndici, dispositivo, 0, Pool.Default)
        Dim indici As Integer() = New Integer(NumeroIndici) {}
        indici(0) = 1
        indici(1) = 2
        indici(2) = 0
        indici(3) = 3
        ib.SetData(indici, 0, LockFlags.None)

Ecco il codice che "stampa":

        dispositivo.RenderState.Lighting = False
        dispositivo.RenderState.CullMode = Cull.None
        dispositivo.RenderState.FillMode = FillMode.WireFrame
        dispositivo.Clear(ClearFlags.Target, Color.Black, 1, 0)
        dispositivo.BeginScene()
        dispositivo.VertexFormat = CustomVertex.PositionColored.Format
        dispositivo.SetStreamSource(0, VBuffer, 0)
        dispositivo.Indices = ib

        dispositivo.DrawIndexedPrimitives(PrimitiveType.TriangleStrip, 0, 0, 4, 0, 2)
        dispositivo.EndScene()
        dispositivo.Present()

Che cosa ottengo con tutto questo?

Ho problemi con l'ordine dei vertici.
Cerchiamo innanzitutto di stabilire il punto di vista mediante la View Matrix:

        dispositivo.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, 15), New Vector3(0, 0, 0), New Vector3(0, 1, 0))

Ecco: creo due triangoli in una TriangleStrip.
Creo il VertexBuffer:

VBuffer = New VertexBuffer(GetType(CustomVertex.PositionColored), NumeroVertici, dispositivo, 0, CustomVertex.PositionColored.Format, Pool.Default)
        Dim vertici As CustomVertex.PositionColored() = New CustomVertex.PositionColored(NumeroVertici) {}
        vertici(0).Position = New Vector3(0, 0, 0)
        vertici(0).Color = Color.Blue.ToArgb
        vertici(1).Position = New Vector3(5, 0, 0)
        vertici(1).Color = Color.Yellow.ToArgb
        vertici(2).Position = New Vector3(5, 5, 0)
        vertici(2).Color = Color.Red.ToArgb
        vertici(3).Position = New Vector3(0, 5, 0)
        vertici(3).Color = Color.Green.ToArgb

Creo l'IndexBuffer:

        ib = New IndexBuffer(GetType(Integer), NumeroIndici, dispositivo, 0, Pool.Default)
        Dim indici As Integer() = New Integer(NumeroIndici) {}
        indici(0) = 0
        indici(1) = 1
        indici(2) = 2
        indici(3) = 3
        ib.SetData(indici, 0, LockFlags.None)

Ecco il risultato:

Qui il triangolo è stato tracciato nell'ordine dei vertici rosso, giallo e blu. L'ultimo ad essere stato tracciato è il cateto verticale, e il nuovo triangolo è stato tracciato avendo in comune con esso questo cateto.
Adesso tracciamo per ultimo il cateto orizzontale:

ib = New IndexBuffer(GetType(Integer), NumeroIndici, dispositivo, 0, Pool.Default)
        Dim indici As Integer() = New Integer(NumeroIndici) {}
        indici(0) = 2
        indici(1) = 0
        indici(2) = 1
        indici(3) = 3

E ora tracciamo per ultima l'ipotenusa:

        ib = New IndexBuffer(GetType(Integer), NumeroIndici, dispositivo, 0, Pool.Default)
        Dim indici As Integer() = New Integer(NumeroIndici) {}
        indici(0) = 1
        indici(1) = 2
        indici(2) = 0
        indici(3) = 3

Annotazioni informali sulla creazione di VertexBuffer e IndexBuffer.

Bene. Dunque la creazione di un buffer sarebbe motivata dal dover archiviare una grande quantità di vertici.
C'è una differenza nel metodo che disegna le "primitive".

device.DrawUserPrimitives(PrimitiveType.TriangleList, 1, vertices)

e

 device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 5, 0, 2);

Si tratta di due metodi differenti.
Vediamo i parametri assunti dal primo.

device.DrawUserPrimitives(PrimitiveType.TriangleList, 1, vertices)

 device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 5, 0, 2);

Mentre il primo metodo, DrawUserPrimitives, prende come argomenti il tipo di primitiva, il numero di elementi da disegnare e i vertici,
il secondo, DrawIndexedPrimitives, prende come argomenti il tipo di primitiva, quattro numeri che devo ancora studiare e, da ultimo, il numero di elementi da disegnare.

Mancano i vertici.
Dove sono?

Ecco: ci sono due membri dell'oggetto Device:

 device.SetStreamSource(0, vb, 0);
 device.Indices = ib;

laddove vb sta per VertexBuffer, e ib sta per IndexBuffer

Quindi, prima, ci sono due oggetti, un VertexBuffer e un IndexBuffer, che vengono costruiti.

Mi sembra chiaro che DrawIndexedPrimitives prenda i suoi vertici dal membro device.Indices.

---

Da quello che ho capito il VertexBuffer contiene tutti i punti che vanno a fare da vertici, senza ripeterli quando essi siano uguali.
Costruiamo questo VertexBuffer...

        Dim VBuffer As New VertexBuffer(GetType(CustomVertex.PositionColored),3,dispositivo,0,CustomVertex.PositionColored.Format,pool.Default)

Non mi sono chiari tutti i parametri e il loro perchè...

Costruiamo i vertici...
Prima l'array;

Dim vertici As CustomVertex.PositionColored() = New CustomVertex.PositionColored(3) {}

Quindi tutti i vertici, in questo caso tre:

        vertici(0).Position = New Vector3(0, 0, 0)
        vertici(0).Color = Color.Blue.ToArgb
        vertici(1).Position = New Vector3(10, 0, 0)
        vertici(1).Color = Color.Red.ToArgb
        vertici(2).Position = New Vector3(0, 10, 0)
        vertici(2).Color = Color.Yellow.ToArgb

Dunque, creata la matrice di vertici, ossia CustomVertex.PositionColored, e creati i vertici, bisogna "associarli" in qualche modo a VertexBuffer.
Ed ecco che trovo questa istruzione:

VBuffer.SetData(vertici, 0, LockFlags.None)

In sintesi:

• Creazione di VertexBuffer
• Creazione di un array di vertici
• "associazione" dell'array di vertici al VertexBuffer.

---

Adesso si deve creare un IndexBuffer

Ecco, alla fine ci sono riuscito.

 ib = New IndexBuffer(GetType(Integer), 3, dispositivo, 0, Pool.Default)
        Dim indici As Integer() = New Integer(3) {}
        indici(0) = 0
        indici(1) = 1
        indici(2) = 2
        ib.SetData(indici, 0, LockFlags.None)

Adesso il mio programma non fa assolutamente niente, ma almeno non dà messaggi di errore.
E' già qualcosa...

Appunti informali su VertexBuffer

Praticamente InitializeGraphics non fa altro che settare i parametri e creare il device:

    Private Sub InitializeGraphics()
        Dim parametri As New PresentParameters
        parametri.SwapEffect = SwapEffect.Discard
        parametri.Windowed = True
        dispositivo = New Device(0, DeviceType.Hardware, Me, CreateFlags.SoftwareVertexProcessing, parametri)
    End Sub

E la inseriamo in Form_Load:

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        InitializeGraphics()
    End Sub

---

---

E fin qua ci siamo.

---

---

Ora creiamo la subroutine Render, ossia il suo scheletro:

    Private Sub Render()
        dispositivo.BeginScene()
        dispositivo.EndScene()
        dispositivo.Present()
    End Sub

o meglio:

    Private Sub Render()
        dispositivo.Clear(ClearFlags.Target, Color.Black, 1, 0)
        dispositivo.BeginScene()
        dispositivo.EndScene()
        dispositivo.Present()
    End Sub

Il metodo Clear come funziona?
Lasciamolo perdere, altrimenti qua ci disperdiamo... Lo vedrò dopo.

Adesso si costruisce un buffer.
La costruzione del buffer è delegata a una subroutine CreateVertexBuffer:

    Private Sub CreateVertexBuffer()
        Dim BufferVertici As New VertexBuffer(GetType(CustomVertex.PositionColored), 3, dispositivo, 0, CustomVertex.PositionColored.Format, Pool.Default)

    End Sub

Ma ora, che ci faccio con questo BufferVertici? Nell'altro tutorial non era contemplato...

Primo abbozzo sulla comprensione della World Matrix

Dunque...
Io ho un triangolo con uno dei suoi vertici situato nel punto 0,0,0. Le coordinate dei vertici sono rispettivamente:

0, 0, 0

0.5, 0, 0

0, 1, 0

Viene ruotato di un certo angolo θ sul suo vertice posto in 0,0,0. Le nuove coordinate saranno, per i due vertici che subiscono lo spostamento:

0,0,0

0.5*cosθ, 0.5*sinθ, 0

-1*sinθ, 1*cosθ,   0

C'è qualcosa che non mi è chiaro: quale sia l'ordine dei vertici, e perchè nella matrice del tutorial che sto consultando il vertice che sta a zero non presenta tutte le coordinate a zero ma ne presenta una a 1.
Il principio l'ho capito, ma devo ancora ragionarci un po' su...

Cambio dei punti di vista lungo l'asse delle Z nella visualizzazione di un triangolo.

E se provassi a fare un viaggio sequenziale lungo l'asse delle Z, avvicinandomi da dietro al triangolo e quindi trapassandone il piano frontale e avvicinandomi ancora?

Fatto!

---

Punto di vista 0,0,8:

        device.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, 3), New Vector3(0, 0, 0), New Vector3(0, 1, 0))

---

Punto di vista 0,0,3:

        device.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, 8), New Vector3(0, 0, 0), New Vector3(0, 1, 0))

---

Punto di vista 0,0,-3

        device.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, -3), New Vector3(0, 0, 0), New Vector3(0, 1, 0))

Ecco: ho "trapassato" il piano su cui si trova il triangolo e gli sono passato davanti, così adesso lo vedo "dall'altro lato".

---

Punto di vista 0,0,-8

        device.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, -8), New Vector3(0, 0, 0), New Vector3(0, 1, 0))

Cominciamo a venire a capo di qualcosa di concreto su Direct3D

Forse sto venendo a capo.
Ragioniamo.
Ho un triangolo con i vertici di colore diverso:Blu, Verde e Rosso. Le coordinate dei vertici sono rispettivamente:

• Blu: x=0,y=0,z=0
• Verde: x=0.5, y=0, z=0
• Rosso: x=0, y=0.5, z=0

Lasciamo la coordinata z invariata, ossia si trova perfettamente sul piano frontale.

Ora imposto il punto di vista, il punto puntato e l' "alto".

 device.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, 2), New Vector3(0, 0, 0), New Vector3(0, 1, 0)) 

Il punto di vista dovrebbe essere di 2 unità "dietro" il triangolo.
Per questo il triangolo si vede così:

Questo perchè lo 0 dell'asse Z è "dietro".
Inverto la coordinata Z del punto di vista:

evice.Transform.View = Matrix.LookAtLH(New Vector3(0, 0, -2), New Vector3(0, 0, 0), New Vector3(0, 1, 0))

Ed ecco l'immagine:

---

E finalmente cominciamo a venirne a capo.

Appunti informali su DirectX

Customvertex. Che è 'sta roba?

Contenitore di strutture.

Forse sarebbe il caso di creare delle strutture e vedere come una classe possa essere un contenitore di strutture.

Public Class Form1

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        Dim mia As Raccolta.Tipo
        mia = New Raccolta.Tipo
        mia.proprieta = "uno"
        mia.proprieta2 = "due"

        Dim mietta As Raccolta.Tipetto
        mietta = New Raccolta.Tipetto
        mietta.proprieta = "unetto"
        mietta.proprieta2 = "duetto"
    End Sub


End Class


Class Raccolta
    Public Structure Tipo
        Public proprieta As String
        Public proprieta2 As String
    End Structure

    Public Structure Tipetto
        Public proprieta As String
        Public proprieta2 As String
    End Structure
End Class

Ecco, qualcosa del genere.

---

Che macello!
Cerchiamo di analizzare la cosa per venirne a capo... Sto in crisi!!!

        Dim present As PresentParameters = New PresentParameters
        present.Windowed = True 'we?ll draw on a window
        present.SwapEffect = SwapEffect.Discard 'discuss later
        device = New Direct3D.Device(0, DeviceType.Hardware, Me, CreateFlags.SoftwareVertexProcessing, present)

Che cosa è PresentParameters?
Facciamo una ricerca.

Serve per inizializzare il device.
Come?
Ha un membro Windowed e uno SwapEffect: che significano?
Windowed è facile da capire: è booleano, e se è True significa che l'applicazione si esegue in una finestra.
SwapEffect è più complicato... Qui è settato a Discard.
Che accidenti significa?
Ah, ecco, può essere settato a questi valori:

1. Discard
2. Copy
3. Flip

Ora il casino è vedere che significano questi valori.

Ha a che fare con il metodo Device.Present()
Che metodo è? E' presente qui?
Sì, è presente. Quindi PresentParameters ha a che fare con questo metodo Device.Present
Che fa il metodo Present di Device?
Eccolo copiato direttamente dalla guida di MSDN:
"Presents the display with the contents of the next buffer in the sequence of back buffers owned by the device."

Presenta il display con il contenuto del successivo buffer nella sequenza dei back buffers posseduti dal device.
Bene. Dovrei cercare di capire che significa swap chain
A swap chain is a collection of buffers that are used for displaying frames to the user. Each time an application presents a new frame for display, the first buffer in the swap chain takes the place of the displayed buffer. This process is called swapping or flipping. Quindi una swap chain è una collezione di buffers che sono usati per mostrare i frames all'utente.
Sarebbe la coda di buffers che "fanno la fila" dietro lo schermo per essere presentati.
Questo processo si chiama swapping o flipping.
Collegamento a MSDN.

Bene.
La frequenza di refresh dello schermo va da 60 a 100 Hz.
Se lo swapping ha una frequenza superiore alla frequenza di refresh dello schermo, dato che il disegno dello schermo va dall'alto a sinistra fino al basso a destra, se mentre l'immagine è in fase di disegno si ha lo swapping al buffer successivo, la parte superiore dello schermo contiene l'immagine vecchia mentre quella inferiore contiene l'immagine nuova. Questo effetto si chiama tearing.