Il presente articolo è stato tradotto automaticamente.
DirectX Factor
Geometrie Direct2D e relative manipolazioni
Scaricare il codice di esempio
.jpg)
Geometria del liceo è disponibile in due sapori distinti: La geometria euclidea è orientata intorno costruzioni, teoremi e dimostrazioni, mentre la geometria analitica descrive figure geometriche numericamente utilizzando punti su un sistema di coordinate, spesso chiamato il sistema di coordinate cartesiane in onore del pioniere della geometria analitica, René Descartes.
Si tratta di geometria analitica che costituisce la base dell'ala intero vettore della computer grafica, quindi è giusto e opportuno che un'interfaccia denominata ID2D1Geometry (sei interfacce che derivano da esso e) praticamente si trova nel centro di Direct2D grafica vettoriale.
Nella puntata precedente di questa rubrica (msdn.microsoft.com/magazine/dn342879), discusso di come utilizzare il ID2D1PathGeometry per rendere le linee in un'applicazione finger-painting che gira sotto Windows 8.Vorrei ora un passo indietro ed esplorare geometrie in dettaglio più ampio e indagare in particolare alcuni dei metodi intriganti definiti da ID2D1Geometry per manipolare le geometrie per effettuare diverse geometrie.
Anche se si ha familiarità con l'utilizzo di geometrie in Windows Runtime (WinRT), ID2D1Geometry fornisce servizi che non sono esposti nella classe geometria WinRT.
Informazioni generali
Geometrie fondamentalmente sono insiemi di punti di coordinate.Questi punti di coordinate non sono legati a qualsiasi dispositivo particolare, così geometrie sono oggetti intrinsecamente indipendente dal dispositivo.Per questo motivo, si creano geometrie di vari tipi chiamando i metodi sull'oggetto ID2D1Factory, che è la fabbrica di Direct2D indipendente dal dispositivo.I sei metodi di geometria-creazione sono mostrati Figura 1, insieme al tipo di interfaccia degli oggetti che creano.
Figura 1 le interfacce e i metodi della geometria sei
| Metodo ID2D1Factory | Oggetto creato (derivato da ID2D1Geometry) |
| CreateRectangleGeometry | ID2D1RectangleGeometry |
| CreateRoundedRectangleGeometry | ID2D1RoundedRectangleGeometry |
| CreateEllipseGeometry | ID2D1EllipseGeometry |
| CreatePathGeometry | ID2D1PathGeometry |
| CreateTransformedGeometry | ID2D1TransformedGeometry |
| CreateGeometryGroup | ID2D1GeometryGroup |
Con l'eccezione di CreatePathGeometry, questi metodi creano oggetti immutabili: Tutte le informazioni necessarie per creare l'oggetto viene passate al metodo di creazione, e non puoi cambiare nulla della geometria dopo che è stato creato.
L'unico motivo che l'oggetto ID2D1PathGeometry è diverso è perché CreatePathGeometry restituisce un oggetto che è essenzialmente vuoto.Descriverò come voi riempirlo poco.
CreateTransformedGeometry accetta un oggetto esistente ID2D1Geometry e una matrice di trasformazione affine.La geometria risultante viene tradotto, ridimensionata, ruotata o distorta che Matrix.CreaGeometryGroup metodo accetta una matrice di ID2D1Geometry oggetti e crea una geometria che è il composito di tutte le geometrie individuali.
Se si utilizza il modello di progetto Visual Studio Direct2D (XAML) per creare un'applicazione Windows Store che accede a DirectX, è generalmente creare oggetti geometry nella CreateDeviceIndependentrisorse eseguire l'override della classe rendering e usarli per tutta la durata del programma, in particolare durante l'override del rendering.
L'interfaccia ID2D1RenderTarget (da cui interfacce come ID2D1DeviceContext derivano) definisce due metodi per geometrie di rendering su una superficie di disegno: DrawGeometry e FillGeometry.
Il metodo DrawGeometry disegna le linee e le curve della geometria con un pennello specificato, lo spessore del tratto e stile di corsa, permettendo le linee solide, punteggiate, tratteggiate o personalizzate dash-fantasia.Il metodo FillGeometry riempie locali chiusi di una geometria con un pennello e una maschera di opacità opzionale.È inoltre possibile utilizzare geometrie per ritaglio, che prevede la chiamata PushLayer sulla destinazione di rendering con una struttura D2D1_LAYER_PARAMETERS che include la geometria.
A volte è necessario animare una geometria.L'approccio più efficace consiste nell'applicare una matrice di trasformazione per la destinazione di rendering prima del rendering della geometria.Tuttavia, se questo non è sufficiente, sarà necessario ricreare la geometria, probabilmente durante il metodo di aggiornamento nella classe di rendering.(O, si potrebbe voler creare un mucchio di geometrie sin dall'inizio e salvarle). Anche se ri-creazione di geometrie aumenta il sovraccarico di rendering, è certamente necessario a volte.Ma, per la maggior parte, se non è necessario ri-creare geometrie, non farlo.
Il Sink di geometria
L'oggetto ID2D1PathGeometry è un insieme di linee rette e curve, curve di Bezier specificamente cubiche, quadratica e archi, che sono curve sulla circonferenza di un'ellisse.È possibile controllare se queste linee e le curve sono connessi, e se essi definiscono locali chiusi.
Riempimento di una geometria del percorso con linee e curve prevede l'utilizzo di un oggetto di tipo ID2D1GeometrySink.Questo particolare lavello non è per il lavaggio di geometrie!Pensate a come un ricettacolo — una destinazione per linee e curve che vengono poi mantenute dalla geometria del percorso.
Ecco come costruire una geometria del percorso:
- Creare un oggetto ID2D1PathGeometry chiamando CreatePathGeometry su un oggetto ID2D1Factory.
- Chiamare Apri il ID2D1PathGeometry per ottenere un nuovo oggetto ID2D1GeometrySink.
- Chiamare metodi del ID2D1GeometrySink per aggiungere linee e curve per la geometria del percorso.
- Chiamare Chiudi il ID2D1GeometrySink.
Il ID2D1PathGeometry non è utilizzabile fino a Close è stato chiamato sull'oggetto ID2D1GeometrySink.Dopo la chiamata a Close, il ID2D1PathGeometry non è modificabile: Il contenuto non può essere alterato in alcun modo, e non è possibile chiamare Apri nuovamente.Sink di geometria non ha più uno scopo, e si può sbarazzarsi di esso.
Il terzo elemento nell'elenco coinvolge solitamente il codice più ampio.Una geometria del percorso è un insieme di figure; ogni figura è una serie di righe collegate e curve, denominate segmenti.Quando si chiamano funzioni il ID2D1GeometrySink, si inizia con una chiamata opzionale a SetFillMode per indicare l'algoritmo utilizzato per aree di riempimento racchiuso.Quindi, per ogni serie di righe collegate e curve in geometria del percorso:
- Chiamare BeginFigure, che indica il primo punto e se saranno riempiti locali chiusi.
- Chiamare i metodi che iniziano con la parola Add per aggiungere righe collegate, curve di Bezier e archi alla figura.
- Chiamare EndFigure, che indica se l'ultimo punto dovrebbe essere collegato automaticamente al primo punto con una linea retta.
Quando guardi la documentazione del ID2D1GeometrySink, prendere nota che l'interfaccia deriva da ID2D1SimplifiedGeometrySink, che in realtà definisce i metodi più importanti.Maggiori informazioni su questa differenziazione poco.
Poiché il contenuto di un ID2D1PathGeometry è immutabile una volta che hai definito il relativo percorso, se avete bisogno di modificare un ID2D1Pathgeometria dovrete ricrearlo e passare attraverso il processo di definizione del percorso nuovamente.Tuttavia, se stai aggiungendo solo cifre aggiuntive all'inizio o alla fine di una geometria del percorso esistente, quindi una scelta rapida è disponibile: Si può creare una nuova geometria del percorso, aggiungere alcune figure ad esso e poi trasferire il contenuto della geometria del percorso esistente alla nuova geometria del percorso chiamando la funzione di flusso della geometria del percorso esistente con il nuovo ID2D1GeometrySink.È quindi possibile aggiungere ulteriori figure prima della chiusura.
Disegno e il riempimento
Ora sono pronto a mostrarvi qualche codice.La geometria scaricabileprogetto di sperimentazione è stato creato in Visual Studio 2012 utilizzando il modello Windows Store Direct2D (XAML).Rinominato la classe SimpleTextRenderer GeometryVarietiesRenderer, e rimosso tutto il codice e markup associato il rendering del testo di esempio.
Nel file XAML, definito un gruppo di pulsanti di opzione per le varie tecniche di rendering-geometria.Ogni pulsante di opzione è associato a un membro di un'enumerazione RenderingOption definito.Un grande interruttore e istruzione il Render override usi membri di questa enumerazione RenderingOption per governare il codice che viene eseguito.
Tutta la creazione della geometria si verifica durante il CreateDeviceIndependentResources l'override.Una geometria che crea il programma è una stella a cinque punte.Il metodo piuttosto generalizzata che costruisce questa geometria è mostrato Figura 2.Esso è costituito da una figura con quattro segmenti di linea, ma l'ultimo punto è automaticamente collegato al primo punto.
Figura 2 metodo per costruire una geometria stella cinque-aguzza
HRESULT GeometryVarietiesRenderer::CreateFivePointedStar(
float radius, ID2D1PathGeometry** ppPathGeometry)
{
if (ppPathGeometry == nullptr)
return E_POINTER;
HRESULT hr = m_d2dFactory->CreatePathGeometry(ppPathGeometry);
ComPtr<ID2D1GeometrySink> geometrySink;
if (SUCCEEDED(hr))
{
hr = (*ppPathGeometry)->Open(&geometrySink);
}
if (SUCCEEDED(hr))
{
geometrySink->BeginFigure(Point2F(0, -radius),
D2D1_FIGURE_BEGIN_FILLED);
for (float angle = 2 * XM_2PI / 5;
angle < 2 * XM_2PI; angle += 2 * XM_2PI / 5)
{
float sin, cos;
D2D1SinCos(angle, &sin, &cos);
geometrySink->AddLine(Point2F(radius * sin, -radius * cos));
}
geometrySink->EndFigure(D2D1_FIGURE_END_CLOSED);
hr = geometrySink->Close();
}
return hr;
}
Figura 3 Mostra gran parte del metodo CreateDeviceIndependentResources. (Per mantenere la quotazione semplice, ho rimosso la movimentazione di valori HRESULT errante). Il metodo inizia creando una geometria simile a un'onda quadra, una chiamata per creare la stella a cinque punte e una chiamata a un altro metodo per creare un segno di infinito. Due di queste geometrie sono trasformati, e tutti e tre sono combinati nel metodo CreateGeometryGroup (chiamato in fondo Figura 3) in un membro denominato m_geometryGroup.
Figura 3 molto del CreateDeviceIndependentResources l'Override
void GeometryVarietiesRenderer::CreateDeviceIndependentResources()
{
DirectXBase::CreateDeviceIndependentResources();
// Create square-wave geometry
HRESULT hr = m_d2dFactory->CreatePathGeometry(&m_squareWaveGeometry);
ComPtr<ID2D1GeometrySink> geometrySink;
hr = m_squareWaveGeometry->Open(&geometrySink);
geometrySink->BeginFigure(Point2F(-250, 50),
D2D1_FIGURE_BEGIN_HOLLOW);
geometrySink->AddLine(Point2F(-250, -50));
geometrySink->AddLine(Point2F(-150, -50));
geometrySink->AddLine(Point2F(-150, 50));
geometrySink->AddLine(Point2F(-50, 50));
geometrySink->AddLine(Point2F(-50, -50));
geometrySink->AddLine(Point2F( 50, -50));
geometrySink->AddLine(Point2F( 50, 50));
geometrySink->AddLine(Point2F(150, 50));
geometrySink->AddLine(Point2F(150, -50));
geometrySink->AddLine(Point2F(250, -50));
geometrySink->AddLine(Point2F(250, 50));
geometrySink->EndFigure(D2D1_FIGURE_END_OPEN);
hr = geometrySink->Close();
// Create star geometry and translate it
ComPtr<ID2D1PathGeometry> starGeometry;
hr = CreateFivePointedStar(150, &starGeometry);
hr = m_d2dFactory->CreateTransformedGeometry(starGeometry.Get(),
Matrix3x2F::Translation(0, -200),
&m_starGeometry);
// Create infinity geometry and translate it
ComPtr<ID2D1PathGeometry> infinityGeometry;
hr = CreateInfinitySign(100, &infinityGeometry);
hr = m_d2dFactory->CreateTransformedGeometry(infinityGeometry.Get(),
Matrix3x2F::Translation(0, 200),
&m_infinityGeometry);
// Create geometry group
CreateGeometryGroup();
...
}
Il metodo CreateDeviceIndependentResources crea due stili di corsa con estremità arrotondate e join. Uno è solido e l'altro è punteggiato.
Il metodo CreateDeviceDependentResources crea due spazzole: nero per il disegno e rosso per il riempimento.
Quando si avvia il programma, il primo pulsante di opzione è selezionato e viene chiamato DrawGeometry:
m_d2dContext->DrawGeometry(m_geometryGroup.Get(),
m_blackBrush.Get());
Il risultato è mostrato Figura 4, sembrava stranamente il logo di qualche culto grafica strano.
.png)
Figura 4 la schermata di avvio di GeometryExperimentation
Perché il programma combinato le tre geometrie separate per semplificare il rendering, essi avrete tutti essere resi con lo stesso pennello. In un programma vero, si sarebbe probabilmente mantenere un mucchio di geometrie individuali e colorarli tutti in modo diverso.
Le prime poche opzioni dimostrano come la geometria può essere disegnata con un tratto più spesso e una linea in stile, tra cui una linea tratteggiata. (Per tutto il programma, ictus spessori di 1, 10 e 20 pixel vengono utilizzati e dovrebbero essere facilmente distinguibili visivamente.)
Quando dimostrando percorso geometrie e animazione in XAML, mi piace applicare un'animazione basata su XAML per l'offset del precipitare di uno stile di corsa, causando punti viaggiare intorno alla geometria. Si può fare qualcosa di simile in DirectX (come l'animato Dot Offset opzione dimostra), ma è necessario ricreare in modo esplicito l'oggetto ID2D1StrokeStyle durante ogni refresh dello schermo. Questo accade nel metodo Update.
Locali chiusi della geometria possono anche essere riempiti con un pennello:
m_d2dContext->FillGeometry(m_geometryGroup.Get(),
m_redBrush.Get());
Il risultato viene illustrato nella Figura 5. Esistono aree racchiusi in onda quadra. Il Pentagono interno della stella a cinque punte non è pieno perché la modalità di riempimento è impostata su un algoritmo noto come alternativo. È possibile utilizzare la coppia di pulsanti di opzione in basso a sinistra del Figura 5 per selezionare la modalità di riempimento tortuose per riempire il Pentagono. La modalità di riempimento deve essere specificata quando si crea la ID2D1GeometryGroup, quindi l'oggetto m_geometryGroup deve essere ri-creato quando si fa clic su uno di quei tasti due radio. Se si sovrappongono le geometrie del gruppo di geometria, aree di intersezione sono riempiti anche basata su quella modalità di riempimento.
.png)
Figura 5 riempimento geometrie
Spesso si vorrà sia disegnare e riempire una geometria. In generale ti consigliamo di chiamare prima FillGeometry e poi DrawGeometry per mantenere il tratto completamente visibile.
Geometrie semplificate e semplificando
Si supponga che l'applicazione crea un ID2D1PathGeometry dinamicamente, forse da input dell'utente, e piacerebbe "interrogare" la geometria del percorso per estrarre tutte le figure e i segmenti. Forse piacerebbe salvare queste informazioni in un formato XAML come una serie di tag standard PathGeometry, PathFigure, LineSegment e BezierSegment.
In un primo momento, non sembra come se questo è possibile. Il ID2D1PathGeometry ha i metodi GetFigureCount e GetSegmentCount, ma nessun metodo per estrarre effettivamente quei segmenti e figure.
Ma ricordo il metodo Stream. Questo metodo accetta un ID2D1GeometrySink e copia il contenuto della geometria del percorso in quel lavandino. La chiave qui è che si può scrivere la propria classe che implementa l'interfaccia ID2D1GeometrySink e passare un'istanza di tale classe al metodo Stream. All'interno di questa classe personalizzata, è possibile gestire tutte le chiamate a BeginFigure, AddLine e così via e fare quello che vuoi con loro.
Naturalmente, tale classe non è banale. Avrebbe bisogno di implementazioni di tutti i metodi in ID2D1GeometrySink, come ID2D1SimplifiedGeometrySink e IUnknown.
Tuttavia, c'è un modo per rendere questo lavoro un po ' più facile: L'interfaccia di ID2D1Geometry definisce un metodo denominato Simplify che converte qualsiasi oggetto geometry in una geometria "semplificata" che contiene solo linee rette e spline di Bézier cubiche. Questa impresa è possibile perché la spline di Bézier quadratica e gli archi possono essere approssimati di spline di Bézier cubiche. Questo significa che la classe personalizzata solo deve implementare i metodi ID2D1SimplifiedGeometrySink e IUnknown. Semplicemente passare un'istanza di questa classe personalizzata al metodo semplificate di qualsiasi geometria.
È anche possibile utilizzare semplificate per copiare il contenuto semplificato di una geometria a una nuova geometria del percorso. Ecco il codice in geometriasperimentazione che fa questo (escludendo l'HRESULT controllo):
m_d2dFactory->CreatePathGeometry(&m_simplifiedGeometry);
ComPtr<ID2D1GeometrySink> geometrySink;
m_simplifiedGeometry->Open(&geometrySink);
m_geometryGroup->Simplify(D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
IdentityMatrix(), geometrySink.Get());
geometrySink->Close();
Si noti che il primo argomento al metodo Simplify indica che si desidera sia cubic Beziers e linee rette della geometria del percorso semplificato. È possibile limitare che, a solo le linee, nel qual caso il Bezier curve sono approssimate da una serie di linee rette. Questo è un processo chiamato "appiattimento". Se la conversione viene eseguita con molta precisione non si può dire la differenza visivamente, ma è anche possibile specificare un'appiattimento tolleranza così la curva di Bezier non è approssimata molto bene. Ecco qualche codice in GeometryExperimentation che crea una geometria "grossolanamente semplificata":
m_d2dFactory->CreatePathGeometry(&m_grosslySimplifiedGeometry);
m_grosslySimplifiedGeometry->Open(&geometrySink);
m_geometryGroup->Simplify(D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
IdentityMatrix(), 20, geometrySink.Get());
geometrySink->Close();
L'onda quadrata e stella lo stesso aspetto, ma il segno di infinito non è più così liscio, come mostrato Figura 6. Per impostazione predefinita, la tolleranza di appiattimento è 0,25.
.png)
Figura 6 appiattito grossolanamente segno infinito
Ulteriori manipolazioni di geometria
L'interfaccia di ID2D1Geometry definisce tre metodi aggiuntivi che sono simili a semplificare in quanto calcola una nuova geometria e scriverlo in un ID2D1SimplifiedGeometrySink. Tratterò contorno e Widen qui, ma non CombineWithGeometry (perché non solo qualcosa di interessante con più geometrie sovrapposte, e non ho nessuno in questo programma).
Come si è visto, geometrie di percorso possono avere segmenti intersecanti. Il segno dell'infinito ha un diritto di segmento che si intersecano nel centro, e la stella a cinque punte ha un mucchio di segmenti che si intersecano. Il metodo di contorno definito da ID2D1Geometry crea una nuova geometria del percorso basata su una geometria esistente percorso che elimina tali intersezioni, ma mantiene le stesse aree allegate.
Ecco il codice in GeometryExperimentation che converte il gruppo di geometria in una geometria del percorso delineato:
m_d2dFactory->CreatePathGeometry(&m_outlinedGeometry);
m_outlinedGeometry->Open(&geometrySink);
m_geometryGroup->Outline(IdentityMatrix(), geometrySink.Get());
geometrySink->Close();
Poiché questo oggetto m_outlinedGeometry definisce le stesse aree riempite come m_geometryGroup, è diverso a seconda se il m_geometryGroup è stato creato utilizzando un'alternativa riempire modalità o tortuose riempire.
Il gruppo di geometria originale ha un totale di tre figure: uno per la stella, uno per l'onda quadra e uno per il segno dell'infinito. Se questo gruppo di geometria viene creato con la modalità alternativa di riempire, la geometria delimitata contiene otto figure: Cinque per le cinque punte della stella, una per l'onda quadra e due per il segno dell'infinito. Ma visivamente sembra lo stesso. Se il gruppo di geometria è creato con la modalità di riempimento tortuosa, tuttavia, la geometria delimitata ha un totale di quattro figure: il segno dell'infinito ha due figure come con la modalità alternativa di riempire, ma perché è riempito tutto l'interno della stella, la stella consiste di una figura, come mostrato Figura 7.
.png)
Figura 7 una geometria del percorso delineato
Definire tale una geometria da zero sarebbe matematicamente piuttosto difficile, ma il metodo di contorno lo rende abbastanza facile. Poiché la geometria del percorso definita dalla struttura non contiene nessun segmenti intersecanti, la modalità di riempimento non ha effetto.
Trovo il metodo Widen per essere il più interessante di tutti. Per capire cosa significa Widen, considerare una geometria del percorso che contiene solo una singola linea retta tra due punti. Quando questa geometria viene disegnata, è accarezzò con uno spessore di linea specifico, quindi in realtà viene visualizzato come un rettangolo pieno. Se lo stile della linea include estremità arrotondate, questo rettangolo è ornato da due semicerchi riempite.
Il metodo Widen calcola una geometria del percorso che descrive il contorno dell'oggetto sottoposto a rendering. Per fare questo, Widen richiede argomenti specificando lo spessore desiderato e stile di corsa, proprio come DrawGeometry. Ecco il codice del progetto GeometryExperimentation:
m_d2dFactory->CreatePathGeometry(&m_widenedGeometry);
m_widenedGeometry->Open(&geometrySink);
m_geometryGroup->Widen(20, m_roundedStrokeStyle.Get(),
IdentityMatrix(), geometrySink.Get());
geometrySink->Close();
Notare lo spessore del tratto di 20 pixel. Il programma disegna poi questa geometria allargata utilizzando un spessore di un pixel:
m_d2dContext->DrawGeometry(m_widenedGeometry.Get(),
m_blackBrush.Get(), 1);
Il risultato viene illustrato nella Figura 8. Trovo i manufatti creati da questo processo estremamente interessanti. È come se in qualche modo io sto sbirciando nelle interiora dell'algoritmo disegno.
.png)
Figura 8 ha allargato la geometria del percorso
Il programma GeometryExperimentation consente inoltre la geometria del percorso allargato di riempimento:
m_d2dContext->FillGeometry(m_widenedGeometry.Get(),
m_redBrush.Get());
Riempimento di una geometria del percorso che è stata ampliata con un tratto particolare larghezza e stile di corsa è visivamente identico a delineare il tracciato originale con quella larghezza e stile. La differenza visiva solo tra le opzioni di disegnare tratto largo arrotondato e riempire allargato in GeometryExperimentation è il colore, perché io uso nero per disegno e rosso per il riempimento.
Si potrebbe voler riempire e disegnare una geometria del percorso allargato, ma probabilmente preferisce che i manufatti interni vengono rimossi. In questo modo è estremamente facile. Semplicemente applicare il metodo di contorno alla geometria del percorso allargato:
m_d2dFactory->CreatePathGeometry(&m_outlinedWidenedGeometry);
m_outlinedWidenedGeometry->Open(&geometrySink);
m_widenedGeometry->Outline(IdentityMatrix(), geometrySink.Get());
geometrySink->Close();
Ora quando si riempiono e disegnare la geometria delineato percorso allargato, si ottiene l'immagine Figura 9. È priva di artefatti e visivamente molto diverso da qualsiasi altro resi da questo programma, e diverso da tutto ciò vorrei essere abbastanza coraggioso per codice da zero.
.png)
Figura 9 un delineato ha allargato la geometria del percorso, accarezzò e riempito
Tutti gli altri?
C'è un altro metodo che scrive un ID2D1SimplifiedGeometrySink dati di geometria, ma potrebbe essere necessario andare a caccia per esso. Non è tra le interfacce Direct2D. È in DirectWrite, ed è il metodo di GetGlyphRunOutline di IDWriteFontFace. Questo potente metodo genera geometrie percorso da profili di carattere del testo, ed è semplicemente troppo divertente da ignorare. Restate sintonizzati.
Charles Petzold è un collaboratore di lunga data di MSDN Magazine e autore di "Programmazione Windows, 6a edizione" (o ' Reilly Media, 2012), un libro sulla scrittura di applicazioni per Windows 8. Il suo sito Web è charlespetzold.com.
Grazie ai seguenti esperti tecnici per la revisione di questo articolo: Marcovalerio Bahnassi (In|Framez Technology), Worachai Chaoweeraprasit (Microsoft), Anthony Hodsdon (Microsoft) e Michael B. McLaughlin (Bob Taco industrie)
Anthony Hodsdon è stato uno sviluppatore nel team di Direct2D sin dal suo inizio in Windows 7. I suoi interessi professionali includono geometria (analitica ed euclidea) e algoritmi numerici.
Worachai Chaoweeraprasit conduce allo sviluppo di Direct2D e DirectWrite. Egli ama buona tipografia e grafica bendingly veloce. Ha insegnato la sua terza elementare nel suo tempo libero in modo più semplice per programmare rispetto in movimento blocca - ha detto lui è semplicemente chiamato C.
Michael B. McLaughlin è un Visual C++ MVP e titolare del Bob Taco Industries, una società di consulenza e di micro-ISV. Egli fu un MVP di XNA/DirectX ed è un avvocato in pensione. Il sito è bobtacoindustries.com e il suo manico di Twitter è @mikebmcl.
Wessam Bahnassi è un software engineer con grande passione per la computer grafica e giochi. Ha lavorato come un piombo Rendering Engineering di Electronic Arts per 7 anni. Ora egli è Lead Programmer presso In|Framez Technology Corp., un supervisore di Game Developer Network arabo, un MVP DirectX dal 2003 e adesso Visual C++ MVP.