एपीआई-स्वतंत्र वर्टेक्स प्रोसेसिंग के लिए एक अच्छी कोड संरचना क्या है?

Question

वर्तमान में सी # और मैं का उपयोग कर एक 3 डी मीडिया इंजन पर काम कर रहा हूं, मैं थोड़ा कन्डर्रम में आया हूं। मेरे पास मेरे रेंडरिंग लूप का पता लगाया गया है, मुझे एक महान प्लग-इन आर्किटेक्चर और कंटेंट मैनेजमेंट सिस्टम और यहां तक ​​कि एक भौतिक पाइपलाइन भी बनाई गई है। फिर इंजन को डायरेक्टएक्स और ओपनजीएल ('रेंडरर' प्लग-इन के माध्यम से) का उपयोग करने की योजना बनाई जाती है, साथ ही दोनों एपीआई प्रोग्राममेबल पाइप लाइन के साथ।

वैसे भी, इस हफ्ते की शुरुआत में मैंने प्रोसेस प्रोसेसिंग के लिए इंजन सार परत पर काम करना शुरू किया (अब मैं इसे हफ्तों के लिए डर रहा हूं)। और जैसा कि आप में से कुछ जानते हैं, ग्राफिक एपीआई के बीच वर्टेक्स हैंडलिंग 'सभी संबंधित या समान नहीं है। अच्छी तरह से संबंधित;), लेकिन वही नहीं। ओपनजीएल हैंडलिंग शिखर में बहुत सीधी-आगे है, आप कस्टम वर्टेक्स संरचना बनाते हैं, इसे GPU को भेजें और फिर अपने शेडर्स को बाकी हिस्सों को संभालें। यह एक लचीली ग्राफिक्स पाइप लाइन के लिए एकदम सही है, ओपनजीएल को यह जानने की आवश्यकता नहीं है कि प्रत्येक वर्टेक्स के साथ कौन से तत्व निहित हैं। दूसरी ओर डायरेक्टएक्स के लिए हमें प्रत्येक चरम संरचना के लिए घोषणाएं बनाने की आवश्यकता होती है और फिर उन्हें GPU को भेजना पड़ता है।

मुद्दा यह है कि मुझे नहीं पता कि किस प्रकार की वर्टेक्स संरचना पारित की जा रही है और मैं निश्चित रूप से अमूर्त परत बनाने से बचना चाहूंगा जिसमें अंकन के प्रत्येक तत्व को गणनाओं और कुछ सार 'वर्टेक्स डिसक्लेरेशन' वर्ग के माध्यम से घोषित करना शामिल है; इससे कुछ समस्याएं पैदा हो जाएंगी:

1) वर्टेक्स तत्व प्राप्त करना कम से कम कहने का दर्द होगा। मैं कुछ 'VertexSemantic' का उपयोग कर सकता हूं और vertex 'a - z' की स्थिति के लिए पूछ सकता हूं, लेकिन कंकाल एनीमेशन जैसे कुछ के लिए बहुत सारे शिखर संसाधित करते समय, इसमें बहुत अधिक उपर हो सकता है।

2) इंजन के मुख्य फोकस 'newbies' पर विचार करने के लिए बहुत उपयोगकर्ता के अनुकूल नहीं है। मैं चाहता हूं कि उपयोगकर्ता कस्टम वर्टिस और जाल बफर बनाने में सक्षम हों, बिना किसी वस्तु के घोषित किए, मूल्यवान विकास समय का उपभोग करें।

3) और अधिक?

अब मैं गुणों के साथ कुछ कर सकता हूं और फिर डायरेक्टएक्स रेंडरर के अंदर वर्टेक्स संरचनाओं के लिए घोषणाएं कर सकता हूं। उदाहरण के लिए, आगे जाना है और कुछ enums बनाएँ:

public class VertexElementAttribute : Attribute 
    { 
     #region Properties 
     /// <summary> 
     /// Gets the total size (in bytes) of the element. 
     /// </summary> 
     public int Size 
     { 
      get; 
      set; 
     } 
     /// <summary> 
     /// Gets the number of values contained with-in the element. 
     /// </summary> 
     public int Count 
     { 
      get; 
      set; 
     } 
     /// <summary> 
     /// Gets the type semantic of the element. 
     /// </summary> 
     public ElementType Type 
     { 
      get; 
      set; 
     } 
     /// <summary> 
     /// Gets the usage semantic of the element. 
     /// </summary> 
     public ElementUsage Usage 
     { 
      get; 
      set; 
     } 
     #endregion 

     #region Init 
     /// <summary> 
     /// Creates a new vertex element attribute. 
     /// </summary> 
     /// <param name="count">The number of values contained within the element.</param> 
     /// <param name="size">The total size (in bytes) of the element.</param> 
     /// <param name="type">The type semantic of the element.</param> 
     /// <param name="usage">The usage semantic of the element.</param> 
     public VertexElementAttribute(int count, int size, ElementType type, ElementUsage usage) 
     { 
      Count = count; 
      Size = size; 
      Type = type; 
      Usage = usage; 
     } 
     #endregion 
    } 

का एक उदाहरण:

// for getting the format layout of the element 
public enum ElementFormat 
{ 
    Float, Float2, Float3, Byte, etc, etc 
} 
// for determining the 'usage' 
// (here is 'another' where DirectX limits vertex structures ><) 
public enum ElementUsage 
{ 
    Position, Normal, Color, TextureCoord, etc, etc 
} 

अब मैं एक विशेषता है कि उपयोगकर्ताओं को प्रत्येक तत्व के अपने शिखर संरचना में 'खानों' के लिए आवेदन कर सकते हैं बना सकते हैं एक कस्टम वर्टेक्स संरचना कैसा दिख सकता है:

public struct VertexPositionColor 
{ 
    [VertexElement(3, sizeof(Vector3), ElementType.FLOAT3, ElementUsage.POSITION)] 
    public Vector3 Xyz; 
    [VertexElement(4, sizeof(Color), ElementType.FLOAT4, ElementUsage.COLOR)] 
    public Color Rgba; 

    ... etc 
} 

यह अच्छा होगा। डायरेक्टएक्स प्लग-इन (रेंडरर) में मैं केवल एक उपयोगिता वर्ग बना सकता हूं जो प्रत्येक संरचना प्रकार के लिए अर्थशास्त्र बना सकता है और फिर डेटा को कैश कर सकता है ताकि प्रत्येक वर्टेक्स के लिए घोषणाओं को पुनर्निर्मित नहीं किया जा सके।

मैं भी ELementUsage पर गणना मूल्य जोड़ सकता हूं ताकि कस्टम मानों का कभी भी उपयोग किया जा सके ... लेकिन फिर वे केवल ओपनजीएल में काम करेंगे क्योंकि डायरेक्टएक्स के लिए आपको प्रत्येक चरम पर निशान लगाने की आवश्यकता होती है ... जब तक वहां कुछ ऐसा है जो मुझे याद आ रहा है।

मेरा प्रश्न (ओं):

वहाँ (attirbutes का उपयोग कर अतिरिक्त) इस बारे में जाने के लिए एक बेहतर तरीका है? क्या DirectX में VertexDeclarations का उपयोग करने से बचने का कोई तरीका है? क्या कोई ऐसी चीज है जिसे आप 'मेरे' प्रश्न के बारे में नहीं समझ सकते?

संपादित करें:

विशेषताओं का उपयोग प्रत्येक शिखर से तत्व डेटा प्राप्त होगा से जुड़ा एक मुद्दा। मान लें कि मैं जाल बफर में प्रत्येक चरम की स्थिति प्राप्त करना चाहता था। चूंकि मैं गुणों के साथ गया, मैं केवल 'vertex.Position' नहीं कर सकता, मुझे एक उपयोगिता विधि बनाना होगा जो एक चरम संरचना से फ़ील्ड संदर्भ निकाल सकता है, जैसे 'Utility.GetElement (vertex, ElementUsage.POSITION)' । इस विधि को पहले विशेषता खोजने के लिए प्रतिबिंब का उपयोग करने की आवश्यकता होगी, फिर फ़ील्ड मान के संदर्भ को वापस कर दें। मूल्य निर्धारित करना भी मुझे नहीं लगता (मुझे लगता है) संभव है?

एक और तरीका एक आईलेमेंट इंटरफ़ेस बनाना और प्रत्येक तत्व (Positon, Normal, आदि) को लागू करना होगा। इंटरफ़ेस में नाम संपत्ति हो सकती है जिसे मैं सीधे विरासत तत्व संरचना के अंदर वापस कर सकता हूं, जैसे PositionElements 'नाम संपत्ति "Positon" वापस आ जाएगी।

अगला मैं एक वर्टेक्स संरचना के अंदर आईलेमेंट की सरणी रख सकता हूं जिसमें AddElement (IElement), GetElement (string name), GetElement (int index), Insert, Replace, आदि जैसी विधियां शामिल हैं। मैं सभी तत्वों को लागू करता हूं डायरेक्टएक्स ताकि रेंडरर प्लग-इन वर्टेक्स घोषणाओं की एक सरणी बनाने के लिए वर्टेक्स संरचना को पार्स कर सके।

इसके साथ समस्या यह है कि मुझे यकीन नहीं है कि एक सरणी [[] 'वर्टेक्स तत्व डेटा के रूप में उपयोग की जा सकती है या नहीं। जैसे, अन्य बाइट्स में एक सरणी में क्या होता है (यदि कोई है) जो मुझे वर्टेक्स स्ट्रक्चर (आईलेमेंट सरणी शामिल करता है) को सीधे डायरेक्टएक्स पर ले जाने से रोकता है, फिर GPU पर?

इस तरह इसे लागू करने के लिए मुझे इसकी आवश्यकता के लिए बिल्कुल सही होगा। एक और सवाल यह है कि विरासत के विरासत प्रकार (तत्व) एक वर्ग हो सकते हैं, या तत्व मानों को मूल्य-प्रकार होना चाहिए?

Answer 1

यह लंबे समय से रहा है क्योंकि मैंने कोई डायरेक्टएक्स या ओपनग्ल किया है, इसलिए नमक के अनाज के साथ मेरी सलाह लें, लेकिन मुझे कुछ समय पहले कुछ करना याद है।

मुझे लगता है कि मैं कुछ इस तरह किया:

var graphicsStream = new GraphicsStream(); 

var elements = graphicsStream.Create<Vector3>(Usage.Position); 
graphicsStream.Create<Color>(Usage.Color); 
graphicsStream.Create<Quaternion>(Usage.Fribble); 

elements.SetData(new[] { new Vector3(), new Vector3() }); 

var vertexFormat = graphicsStream.GetFormat(); 
graphicsStream.Validate(); // ensure all the streams have the same length 

// get a particular element by type 
var p = graphicsStream.GetData(Usage.Position, 1); 

आप एक ग्राफिक्स धारा जो एक उपयोग लागू होने के साथ लिखे गए डेटा सेट का एक सेट था होगा। इससे आप एक उचित vertex प्रारूप उत्पन्न कर सकते हैं। एपीआई आपको अलग-अलग तत्वों को बदलने या एक ही बार में पूरे वर्टेक्स बफर को अपलोड और प्रतिस्थापित करने देगी।

सबसे बड़ा नकारात्मक पक्ष यह है कि आपके पास एक संरचना नहीं है जो आपकी चरम संरचना में "कॉलम" का प्रतिनिधित्व करती है।

मुझे नहीं पता कि यह ऐसी चीज है जिसे आप ढूंढ रहे हैं। इस तरह का एक डिजाइन उचित क्यों नहीं होगा?

Answer 2

आप देख सकते हैं कि कैसे OGRE इसे संभालता है। VertexElement के बारे में विशेष रूप से The render system documentation और vertex buffer classes पर भी। ओजीआरई सी ++ है लेकिन मुझे यकीन है कि आप डिज़ाइन पैटर्न आसानी से सी # में परिवर्तित कर पाएंगे।