1  using OpenTK.Graphics.OpenGL;
  2  using Ryujinx.Common.Logging;
  3  using Ryujinx.Graphics.GAL;
  4  using Ryujinx.Graphics.Shader;
  5  
  6  namespace Ryujinx.Graphics.OpenGL
  7  {
  8      static class EnumConversion
  9      {
 10          public static TextureWrapMode Convert(this AddressMode mode)
 11          {
 12              switch (mode)
 13              {
 14                  case AddressMode.Clamp:
 15                      return TextureWrapMode.Clamp;
 16                  case AddressMode.Repeat:
 17                      return TextureWrapMode.Repeat;
 18                  case AddressMode.MirrorClamp:
 19                      return (TextureWrapMode)ExtTextureMirrorClamp.MirrorClampExt;
 20                  case AddressMode.MirrorClampToEdge:
 21                      return (TextureWrapMode)ExtTextureMirrorClamp.MirrorClampToEdgeExt;
 22                  case AddressMode.MirrorClampToBorder:
 23                      return (TextureWrapMode)ExtTextureMirrorClamp.MirrorClampToBorderExt;
 24                  case AddressMode.ClampToBorder:
 25                      return TextureWrapMode.ClampToBorder;
 26                  case AddressMode.MirroredRepeat:
 27                      return TextureWrapMode.MirroredRepeat;
 28                  case AddressMode.ClampToEdge:
 29                      return TextureWrapMode.ClampToEdge;
 30              }
 31  
 32              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(AddressMode)} enum value: {mode}.");
 33  
 34              return TextureWrapMode.Clamp;
 35          }
 36  
 37          public static NvBlendEquationAdvanced Convert(this AdvancedBlendOp op)
 38          {
 39              switch (op)
 40              {
 41                  case AdvancedBlendOp.Zero:
 42                      return NvBlendEquationAdvanced.Zero;
 43                  case AdvancedBlendOp.Src:
 44                      return NvBlendEquationAdvanced.SrcNv;
 45                  case AdvancedBlendOp.Dst:
 46                      return NvBlendEquationAdvanced.DstNv;
 47                  case AdvancedBlendOp.SrcOver:
 48                      return NvBlendEquationAdvanced.SrcOverNv;
 49                  case AdvancedBlendOp.DstOver:
 50                      return NvBlendEquationAdvanced.DstOverNv;
 51                  case AdvancedBlendOp.SrcIn:
 52                      return NvBlendEquationAdvanced.SrcInNv;
 53                  case AdvancedBlendOp.DstIn:
 54                      return NvBlendEquationAdvanced.DstInNv;
 55                  case AdvancedBlendOp.SrcOut:
 56                      return NvBlendEquationAdvanced.SrcOutNv;
 57                  case AdvancedBlendOp.DstOut:
 58                      return NvBlendEquationAdvanced.DstOutNv;
 59                  case AdvancedBlendOp.SrcAtop:
 60                      return NvBlendEquationAdvanced.SrcAtopNv;
 61                  case AdvancedBlendOp.DstAtop:
 62                      return NvBlendEquationAdvanced.DstAtopNv;
 63                  case AdvancedBlendOp.Xor:
 64                      return NvBlendEquationAdvanced.XorNv;
 65                  case AdvancedBlendOp.Plus:
 66                      return NvBlendEquationAdvanced.PlusNv;
 67                  case AdvancedBlendOp.PlusClamped:
 68                      return NvBlendEquationAdvanced.PlusClampedNv;
 69                  case AdvancedBlendOp.PlusClampedAlpha:
 70                      return NvBlendEquationAdvanced.PlusClampedAlphaNv;
 71                  case AdvancedBlendOp.PlusDarker:
 72                      return NvBlendEquationAdvanced.PlusDarkerNv;
 73                  case AdvancedBlendOp.Multiply:
 74                      return NvBlendEquationAdvanced.MultiplyNv;
 75                  case AdvancedBlendOp.Screen:
 76                      return NvBlendEquationAdvanced.ScreenNv;
 77                  case AdvancedBlendOp.Overlay:
 78                      return NvBlendEquationAdvanced.OverlayNv;
 79                  case AdvancedBlendOp.Darken:
 80                      return NvBlendEquationAdvanced.DarkenNv;
 81                  case AdvancedBlendOp.Lighten:
 82                      return NvBlendEquationAdvanced.LightenNv;
 83                  case AdvancedBlendOp.ColorDodge:
 84                      return NvBlendEquationAdvanced.ColordodgeNv;
 85                  case AdvancedBlendOp.ColorBurn:
 86                      return NvBlendEquationAdvanced.ColorburnNv;
 87                  case AdvancedBlendOp.HardLight:
 88                      return NvBlendEquationAdvanced.HardlightNv;
 89                  case AdvancedBlendOp.SoftLight:
 90                      return NvBlendEquationAdvanced.SoftlightNv;
 91                  case AdvancedBlendOp.Difference:
 92                      return NvBlendEquationAdvanced.DifferenceNv;
 93                  case AdvancedBlendOp.Minus:
 94                      return NvBlendEquationAdvanced.MinusNv;
 95                  case AdvancedBlendOp.MinusClamped:
 96                      return NvBlendEquationAdvanced.MinusClampedNv;
 97                  case AdvancedBlendOp.Exclusion:
 98                      return NvBlendEquationAdvanced.ExclusionNv;
 99                  case AdvancedBlendOp.Contrast:
100                      return NvBlendEquationAdvanced.ContrastNv;
101                  case AdvancedBlendOp.Invert:
102                      return NvBlendEquationAdvanced.Invert;
103                  case AdvancedBlendOp.InvertRGB:
104                      return NvBlendEquationAdvanced.InvertRgbNv;
105                  case AdvancedBlendOp.InvertOvg:
106                      return NvBlendEquationAdvanced.InvertOvgNv;
107                  case AdvancedBlendOp.LinearDodge:
108                      return NvBlendEquationAdvanced.LineardodgeNv;
109                  case AdvancedBlendOp.LinearBurn:
110                      return NvBlendEquationAdvanced.LinearburnNv;
111                  case AdvancedBlendOp.VividLight:
112                      return NvBlendEquationAdvanced.VividlightNv;
113                  case AdvancedBlendOp.LinearLight:
114                      return NvBlendEquationAdvanced.LinearlightNv;
115                  case AdvancedBlendOp.PinLight:
116                      return NvBlendEquationAdvanced.PinlightNv;
117                  case AdvancedBlendOp.HardMix:
118                      return NvBlendEquationAdvanced.HardmixNv;
119                  case AdvancedBlendOp.Red:
120                      return NvBlendEquationAdvanced.RedNv;
121                  case AdvancedBlendOp.Green:
122                      return NvBlendEquationAdvanced.GreenNv;
123                  case AdvancedBlendOp.Blue:
124                      return NvBlendEquationAdvanced.BlueNv;
125                  case AdvancedBlendOp.HslHue:
126                      return NvBlendEquationAdvanced.HslHueNv;
127                  case AdvancedBlendOp.HslSaturation:
128                      return NvBlendEquationAdvanced.HslSaturationNv;
129                  case AdvancedBlendOp.HslColor:
130                      return NvBlendEquationAdvanced.HslColorNv;
131                  case AdvancedBlendOp.HslLuminosity:
132                      return NvBlendEquationAdvanced.HslLuminosityNv;
133              }
134  
135              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(AdvancedBlendOp)} enum value: {op}.");
136  
137              return NvBlendEquationAdvanced.Zero;
138          }
139  
140          public static All Convert(this AdvancedBlendOverlap overlap)
141          {
142              switch (overlap)
143              {
144                  case AdvancedBlendOverlap.Uncorrelated:
145                      return All.UncorrelatedNv;
146                  case AdvancedBlendOverlap.Disjoint:
147                      return All.DisjointNv;
148                  case AdvancedBlendOverlap.Conjoint:
149                      return All.ConjointNv;
150              }
151  
152              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(AdvancedBlendOverlap)} enum value: {overlap}.");
153  
154              return All.UncorrelatedNv;
155          }
156  
157          public static All Convert(this BlendFactor factor)
158          {
159              switch (factor)
160              {
161                  case BlendFactor.Zero:
162                  case BlendFactor.ZeroGl:
163                      return All.Zero;
164                  case BlendFactor.One:
165                  case BlendFactor.OneGl:
166                      return All.One;
167                  case BlendFactor.SrcColor:
168                  case BlendFactor.SrcColorGl:
169                      return All.SrcColor;
170                  case BlendFactor.OneMinusSrcColor:
171                  case BlendFactor.OneMinusSrcColorGl:
172                      return All.OneMinusSrcColor;
173                  case BlendFactor.SrcAlpha:
174                  case BlendFactor.SrcAlphaGl:
175                      return All.SrcAlpha;
176                  case BlendFactor.OneMinusSrcAlpha:
177                  case BlendFactor.OneMinusSrcAlphaGl:
178                      return All.OneMinusSrcAlpha;
179                  case BlendFactor.DstAlpha:
180                  case BlendFactor.DstAlphaGl:
181                      return All.DstAlpha;
182                  case BlendFactor.OneMinusDstAlpha:
183                  case BlendFactor.OneMinusDstAlphaGl:
184                      return All.OneMinusDstAlpha;
185                  case BlendFactor.DstColor:
186                  case BlendFactor.DstColorGl:
187                      return All.DstColor;
188                  case BlendFactor.OneMinusDstColor:
189                  case BlendFactor.OneMinusDstColorGl:
190                      return All.OneMinusDstColor;
191                  case BlendFactor.SrcAlphaSaturate:
192                  case BlendFactor.SrcAlphaSaturateGl:
193                      return All.SrcAlphaSaturate;
194                  case BlendFactor.Src1Color:
195                  case BlendFactor.Src1ColorGl:
196                      return All.Src1Color;
197                  case BlendFactor.OneMinusSrc1Color:
198                  case BlendFactor.OneMinusSrc1ColorGl:
199                      return All.OneMinusSrc1Color;
200                  case BlendFactor.Src1Alpha:
201                  case BlendFactor.Src1AlphaGl:
202                      return All.Src1Alpha;
203                  case BlendFactor.OneMinusSrc1Alpha:
204                  case BlendFactor.OneMinusSrc1AlphaGl:
205                      return All.OneMinusSrc1Alpha;
206                  case BlendFactor.ConstantColor:
207                      return All.ConstantColor;
208                  case BlendFactor.OneMinusConstantColor:
209                      return All.OneMinusConstantColor;
210                  case BlendFactor.ConstantAlpha:
211                      return All.ConstantAlpha;
212                  case BlendFactor.OneMinusConstantAlpha:
213                      return All.OneMinusConstantAlpha;
214              }
215  
216              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(BlendFactor)} enum value: {factor}.");
217  
218              return All.Zero;
219          }
220  
221          public static BlendEquationMode Convert(this BlendOp op)
222          {
223              switch (op)
224              {
225                  case BlendOp.Add:
226                  case BlendOp.AddGl:
227                      return BlendEquationMode.FuncAdd;
228                  case BlendOp.Minimum:
229                  case BlendOp.MinimumGl:
230                      return BlendEquationMode.Min;
231                  case BlendOp.Maximum:
232                  case BlendOp.MaximumGl:
233                      return BlendEquationMode.Max;
234                  case BlendOp.Subtract:
235                  case BlendOp.SubtractGl:
236                      return BlendEquationMode.FuncSubtract;
237                  case BlendOp.ReverseSubtract:
238                  case BlendOp.ReverseSubtractGl:
239                      return BlendEquationMode.FuncReverseSubtract;
240              }
241  
242              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(BlendOp)} enum value: {op}.");
243  
244              return BlendEquationMode.FuncAdd;
245          }
246  
247          public static TextureCompareMode Convert(this CompareMode mode)
248          {
249              switch (mode)
250              {
251                  case CompareMode.None:
252                      return TextureCompareMode.None;
253                  case CompareMode.CompareRToTexture:
254                      return TextureCompareMode.CompareRToTexture;
255              }
256  
257              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(CompareMode)} enum value: {mode}.");
258  
259              return TextureCompareMode.None;
260          }
261  
262          public static All Convert(this CompareOp op)
263          {
264              switch (op)
265              {
266                  case CompareOp.Never:
267                  case CompareOp.NeverGl:
268                      return All.Never;
269                  case CompareOp.Less:
270                  case CompareOp.LessGl:
271                      return All.Less;
272                  case CompareOp.Equal:
273                  case CompareOp.EqualGl:
274                      return All.Equal;
275                  case CompareOp.LessOrEqual:
276                  case CompareOp.LessOrEqualGl:
277                      return All.Lequal;
278                  case CompareOp.Greater:
279                  case CompareOp.GreaterGl:
280                      return All.Greater;
281                  case CompareOp.NotEqual:
282                  case CompareOp.NotEqualGl:
283                      return All.Notequal;
284                  case CompareOp.GreaterOrEqual:
285                  case CompareOp.GreaterOrEqualGl:
286                      return All.Gequal;
287                  case CompareOp.Always:
288                  case CompareOp.AlwaysGl:
289                      return All.Always;
290              }
291  
292              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(CompareOp)} enum value: {op}.");
293  
294              return All.Never;
295          }
296  
297          public static ClipDepthMode Convert(this DepthMode mode)
298          {
299              switch (mode)
300              {
301                  case DepthMode.MinusOneToOne:
302                      return ClipDepthMode.NegativeOneToOne;
303                  case DepthMode.ZeroToOne:
304                      return ClipDepthMode.ZeroToOne;
305              }
306  
307              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(DepthMode)} enum value: {mode}.");
308  
309              return ClipDepthMode.NegativeOneToOne;
310          }
311  
312          public static All Convert(this DepthStencilMode mode)
313          {
314              switch (mode)
315              {
316                  case DepthStencilMode.Depth:
317                      return All.DepthComponent;
318                  case DepthStencilMode.Stencil:
319                      return All.StencilIndex;
320              }
321  
322              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(DepthStencilMode)} enum value: {mode}.");
323  
324              return All.Depth;
325          }
326  
327          public static CullFaceMode Convert(this Face face)
328          {
329              switch (face)
330              {
331                  case Face.Back:
332                      return CullFaceMode.Back;
333                  case Face.Front:
334                      return CullFaceMode.Front;
335                  case Face.FrontAndBack:
336                      return CullFaceMode.FrontAndBack;
337              }
338  
339              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(Face)} enum value: {face}.");
340  
341              return CullFaceMode.Back;
342          }
343  
344          public static FrontFaceDirection Convert(this FrontFace frontFace)
345          {
346              switch (frontFace)
347              {
348                  case FrontFace.Clockwise:
349                      return FrontFaceDirection.Cw;
350                  case FrontFace.CounterClockwise:
351                      return FrontFaceDirection.Ccw;
352              }
353  
354              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(FrontFace)} enum value: {frontFace}.");
355  
356              return FrontFaceDirection.Cw;
357          }
358  
359          public static DrawElementsType Convert(this IndexType type)
360          {
361              switch (type)
362              {
363                  case IndexType.UByte:
364                      return DrawElementsType.UnsignedByte;
365                  case IndexType.UShort:
366                      return DrawElementsType.UnsignedShort;
367                  case IndexType.UInt:
368                      return DrawElementsType.UnsignedInt;
369              }
370  
371              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(IndexType)} enum value: {type}.");
372  
373              return DrawElementsType.UnsignedByte;
374          }
375  
376          public static TextureMagFilter Convert(this MagFilter filter)
377          {
378              switch (filter)
379              {
380                  case MagFilter.Nearest:
381                      return TextureMagFilter.Nearest;
382                  case MagFilter.Linear:
383                      return TextureMagFilter.Linear;
384              }
385  
386              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(MagFilter)} enum value: {filter}.");
387  
388              return TextureMagFilter.Nearest;
389          }
390  
391          public static TextureMinFilter Convert(this MinFilter filter)
392          {
393              switch (filter)
394              {
395                  case MinFilter.Nearest:
396                      return TextureMinFilter.Nearest;
397                  case MinFilter.Linear:
398                      return TextureMinFilter.Linear;
399                  case MinFilter.NearestMipmapNearest:
400                      return TextureMinFilter.NearestMipmapNearest;
401                  case MinFilter.LinearMipmapNearest:
402                      return TextureMinFilter.LinearMipmapNearest;
403                  case MinFilter.NearestMipmapLinear:
404                      return TextureMinFilter.NearestMipmapLinear;
405                  case MinFilter.LinearMipmapLinear:
406                      return TextureMinFilter.LinearMipmapLinear;
407              }
408  
409              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(MinFilter)} enum value: {filter}.");
410  
411              return TextureMinFilter.Nearest;
412          }
413  
414          public static OpenTK.Graphics.OpenGL.PolygonMode Convert(this GAL.PolygonMode mode)
415          {
416              switch (mode)
417              {
418                  case GAL.PolygonMode.Point:
419                      return OpenTK.Graphics.OpenGL.PolygonMode.Point;
420                  case GAL.PolygonMode.Line:
421                      return OpenTK.Graphics.OpenGL.PolygonMode.Line;
422                  case GAL.PolygonMode.Fill:
423                      return OpenTK.Graphics.OpenGL.PolygonMode.Fill;
424              }
425  
426              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(GAL.PolygonMode)} enum value: {mode}.");
427  
428              return OpenTK.Graphics.OpenGL.PolygonMode.Fill;
429          }
430  
431          public static PrimitiveType Convert(this PrimitiveTopology topology)
432          {
433              switch (topology)
434              {
435                  case PrimitiveTopology.Points:
436                      return PrimitiveType.Points;
437                  case PrimitiveTopology.Lines:
438                      return PrimitiveType.Lines;
439                  case PrimitiveTopology.LineLoop:
440                      return PrimitiveType.LineLoop;
441                  case PrimitiveTopology.LineStrip:
442                      return PrimitiveType.LineStrip;
443                  case PrimitiveTopology.Triangles:
444                      return PrimitiveType.Triangles;
445                  case PrimitiveTopology.TriangleStrip:
446                      return PrimitiveType.TriangleStrip;
447                  case PrimitiveTopology.TriangleFan:
448                      return PrimitiveType.TriangleFan;
449                  case PrimitiveTopology.Quads:
450                      return PrimitiveType.Quads;
451                  case PrimitiveTopology.QuadStrip:
452                      return PrimitiveType.QuadStrip;
453                  case PrimitiveTopology.Polygon:
454                      return PrimitiveType.TriangleFan;
455                  case PrimitiveTopology.LinesAdjacency:
456                      return PrimitiveType.LinesAdjacency;
457                  case PrimitiveTopology.LineStripAdjacency:
458                      return PrimitiveType.LineStripAdjacency;
459                  case PrimitiveTopology.TrianglesAdjacency:
460                      return PrimitiveType.TrianglesAdjacency;
461                  case PrimitiveTopology.TriangleStripAdjacency:
462                      return PrimitiveType.TriangleStripAdjacency;
463                  case PrimitiveTopology.Patches:
464                      return PrimitiveType.Patches;
465              }
466  
467              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(PrimitiveTopology)} enum value: {topology}.");
468  
469              return PrimitiveType.Points;
470          }
471  
472          public static TransformFeedbackPrimitiveType ConvertToTfType(this PrimitiveTopology topology)
473          {
474              switch (topology)
475              {
476                  case PrimitiveTopology.Points:
477                      return TransformFeedbackPrimitiveType.Points;
478                  case PrimitiveTopology.Lines:
479                  case PrimitiveTopology.LineLoop:
480                  case PrimitiveTopology.LineStrip:
481                  case PrimitiveTopology.LinesAdjacency:
482                  case PrimitiveTopology.LineStripAdjacency:
483                      return TransformFeedbackPrimitiveType.Lines;
484                  case PrimitiveTopology.Triangles:
485                  case PrimitiveTopology.TriangleStrip:
486                  case PrimitiveTopology.TriangleFan:
487                  case PrimitiveTopology.TrianglesAdjacency:
488                  case PrimitiveTopology.TriangleStripAdjacency:
489                      return TransformFeedbackPrimitiveType.Triangles;
490              }
491  
492              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(PrimitiveTopology)} enum value: {topology}.");
493  
494              return TransformFeedbackPrimitiveType.Points;
495          }
496  
497          public static OpenTK.Graphics.OpenGL.StencilOp Convert(this GAL.StencilOp op)
498          {
499              switch (op)
500              {
501                  case GAL.StencilOp.Keep:
502                  case GAL.StencilOp.KeepGl:
503                      return OpenTK.Graphics.OpenGL.StencilOp.Keep;
504                  case GAL.StencilOp.Zero:
505                  case GAL.StencilOp.ZeroGl:
506                      return OpenTK.Graphics.OpenGL.StencilOp.Zero;
507                  case GAL.StencilOp.Replace:
508                  case GAL.StencilOp.ReplaceGl:
509                      return OpenTK.Graphics.OpenGL.StencilOp.Replace;
510                  case GAL.StencilOp.IncrementAndClamp:
511                  case GAL.StencilOp.IncrementAndClampGl:
512                      return OpenTK.Graphics.OpenGL.StencilOp.Incr;
513                  case GAL.StencilOp.DecrementAndClamp:
514                  case GAL.StencilOp.DecrementAndClampGl:
515                      return OpenTK.Graphics.OpenGL.StencilOp.Decr;
516                  case GAL.StencilOp.Invert:
517                  case GAL.StencilOp.InvertGl:
518                      return OpenTK.Graphics.OpenGL.StencilOp.Invert;
519                  case GAL.StencilOp.IncrementAndWrap:
520                  case GAL.StencilOp.IncrementAndWrapGl:
521                      return OpenTK.Graphics.OpenGL.StencilOp.IncrWrap;
522                  case GAL.StencilOp.DecrementAndWrap:
523                  case GAL.StencilOp.DecrementAndWrapGl:
524                      return OpenTK.Graphics.OpenGL.StencilOp.DecrWrap;
525              }
526  
527              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(GAL.StencilOp)} enum value: {op}.");
528  
529              return OpenTK.Graphics.OpenGL.StencilOp.Keep;
530          }
531  
532          public static All Convert(this SwizzleComponent swizzleComponent)
533          {
534              switch (swizzleComponent)
535              {
536                  case SwizzleComponent.Zero:
537                      return All.Zero;
538                  case SwizzleComponent.One:
539                      return All.One;
540                  case SwizzleComponent.Red:
541                      return All.Red;
542                  case SwizzleComponent.Green:
543                      return All.Green;
544                  case SwizzleComponent.Blue:
545                      return All.Blue;
546                  case SwizzleComponent.Alpha:
547                      return All.Alpha;
548              }
549  
550              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(SwizzleComponent)} enum value: {swizzleComponent}.");
551  
552              return All.Zero;
553          }
554  
555          public static ImageTarget ConvertToImageTarget(this Target target)
556          {
557              return (ImageTarget)target.Convert();
558          }
559  
560          public static TextureTarget Convert(this Target target)
561          {
562              switch (target)
563              {
564                  case Target.Texture1D:
565                      return TextureTarget.Texture1D;
566                  case Target.Texture2D:
567                      return TextureTarget.Texture2D;
568                  case Target.Texture3D:
569                      return TextureTarget.Texture3D;
570                  case Target.Texture1DArray:
571                      return TextureTarget.Texture1DArray;
572                  case Target.Texture2DArray:
573                      return TextureTarget.Texture2DArray;
574                  case Target.Texture2DMultisample:
575                      return TextureTarget.Texture2DMultisample;
576                  case Target.Texture2DMultisampleArray:
577                      return TextureTarget.Texture2DMultisampleArray;
578                  case Target.Cubemap:
579                      return TextureTarget.TextureCubeMap;
580                  case Target.CubemapArray:
581                      return TextureTarget.TextureCubeMapArray;
582                  case Target.TextureBuffer:
583                      return TextureTarget.TextureBuffer;
584              }
585  
586              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(Target)} enum value: {target}.");
587  
588              return TextureTarget.Texture2D;
589          }
590  
591          public static NvViewportSwizzle Convert(this ViewportSwizzle swizzle)
592          {
593              switch (swizzle)
594              {
595                  case ViewportSwizzle.PositiveX:
596                      return NvViewportSwizzle.ViewportSwizzlePositiveXNv;
597                  case ViewportSwizzle.PositiveY:
598                      return NvViewportSwizzle.ViewportSwizzlePositiveYNv;
599                  case ViewportSwizzle.PositiveZ:
600                      return NvViewportSwizzle.ViewportSwizzlePositiveZNv;
601                  case ViewportSwizzle.PositiveW:
602                      return NvViewportSwizzle.ViewportSwizzlePositiveWNv;
603                  case ViewportSwizzle.NegativeX:
604                      return NvViewportSwizzle.ViewportSwizzleNegativeXNv;
605                  case ViewportSwizzle.NegativeY:
606                      return NvViewportSwizzle.ViewportSwizzleNegativeYNv;
607                  case ViewportSwizzle.NegativeZ:
608                      return NvViewportSwizzle.ViewportSwizzleNegativeZNv;
609                  case ViewportSwizzle.NegativeW:
610                      return NvViewportSwizzle.ViewportSwizzleNegativeWNv;
611              }
612  
613              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(ViewportSwizzle)} enum value: {swizzle}.");
614  
615              return NvViewportSwizzle.ViewportSwizzlePositiveXNv;
616          }
617  
618          public static All Convert(this LogicalOp op)
619          {
620              switch (op)
621              {
622                  case LogicalOp.Clear:
623                      return All.Clear;
624                  case LogicalOp.And:
625                      return All.And;
626                  case LogicalOp.AndReverse:
627                      return All.AndReverse;
628                  case LogicalOp.Copy:
629                      return All.Copy;
630                  case LogicalOp.AndInverted:
631                      return All.AndInverted;
632                  case LogicalOp.Noop:
633                      return All.Noop;
634                  case LogicalOp.Xor:
635                      return All.Xor;
636                  case LogicalOp.Or:
637                      return All.Or;
638                  case LogicalOp.Nor:
639                      return All.Nor;
640                  case LogicalOp.Equiv:
641                      return All.Equiv;
642                  case LogicalOp.Invert:
643                      return All.Invert;
644                  case LogicalOp.OrReverse:
645                      return All.OrReverse;
646                  case LogicalOp.CopyInverted:
647                      return All.CopyInverted;
648                  case LogicalOp.OrInverted:
649                      return All.OrInverted;
650                  case LogicalOp.Nand:
651                      return All.Nand;
652                  case LogicalOp.Set:
653                      return All.Set;
654              }
655  
656              Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(LogicalOp)} enum value: {op}.");
657  
658              return All.Never;
659          }
660  
661          public static ShaderType Convert(this ShaderStage stage)
662          {
663              return stage switch
664              {
665                  ShaderStage.Compute => ShaderType.ComputeShader,
666                  ShaderStage.Vertex => ShaderType.VertexShader,
667                  ShaderStage.TessellationControl => ShaderType.TessControlShader,
668                  ShaderStage.TessellationEvaluation => ShaderType.TessEvaluationShader,
669                  ShaderStage.Geometry => ShaderType.GeometryShader,
670                  ShaderStage.Fragment => ShaderType.FragmentShader,
671                  _ => ShaderType.VertexShader,
672              };
673          }
674      }
675  }