👢 🀄️ 🚣🏽 कोटलिन पर जीएलएसएल शेड्स का विकास 🙅🏽 🕉️ 🤭

सभी को नमस्कार!

हमारी कंपनी ऑनलाइन गेम विकसित कर रही है और अब हम अपने मुख्य प्रोजेक्ट के मोबाइल संस्करण पर काम कर रहे हैं। इस लेख में हम एक Android प्रोजेक्ट के लिए GLSL शेड बनाने के अनुभव को उदाहरणों और स्रोतों के साथ साझा करना चाहते हैं ।

परियोजना के बारे में

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

एफपीएस बढ़ाने के लिए, ग्राफिक्स इंजन को फिर से डिज़ाइन करने का निर्णय लिया गया था। हम कई सार्वभौमिक शेड्स का उपयोग करते थे, लेकिन अब प्रत्येक प्रभाव के लिए हमने एक अलग शेडर लिखने का फैसला किया, एक विशिष्ट कार्य के लिए तेज किया, ताकि उनके काम को और अधिक कुशल बनाने में सक्षम हो सकें।

हमारे पास क्या कमी थी

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

ताकि:

- कोटलिन पर शेड्स विकसित करें,
- संकलन चरण में एक वाक्यविन्यास जाँच करें,
- shaders के बीच कोड का पुन: उपयोग करने में सक्षम हो,
मुझे GLSL के लिए एक "कनवर्टर" कोटलिन लिखने की आवश्यकता थी।

वांछित परिणाम: शेडर कोड को कोटलिन वर्ग के रूप में वर्णित किया गया है, जिसमें गुण, भिन्नता, वर्दी इस वर्ग के गुण हैं। वर्ग के प्राथमिक निर्माता के मापदंडों का उपयोग स्थिर शाखाओं के लिए किया जाता है और आपको शेष कोड का पुन: उपयोग करने की अनुमति देता है। इनिट ब्लॉक शैडर का शरीर है।

निर्णय

कार्यान्वयन के लिए, कोटलिन प्रतिनिधियों का उपयोग किया गया था। उन्होंने रनटाइम को प्रत्यायोजित संपत्ति के नाम का पता लगाने, कॉल के क्षणों को निर्धारित करने और उन्हें सेट करने और सभी शेड्स के आधार वर्ग - ShaderBuilder को सूचित करने की अनुमति दी।

class ShaderBuilder { val uniforms = HashSet<String>() val attributes = HashSet<String>() val varyings = HashSet<String>() val instructions = ArrayList<Instruction>() ... fun getSource(): String = ... }

प्रतिनिधि कार्यान्वयन

भिन्न प्रतिनिधि:

 class VaryingDelegate<T : Variable>(private val factory: (ShaderBuilder) -> T) { private lateinit var v: T operator fun provideDelegate(ref: ShaderBuilder, p: KProperty<*>): VaryingDelegate<T> { v = factory(ref) v.value = p.name return this } operator fun getValue(thisRef: ShaderBuilder, property: KProperty<*>): T { thisRef.varyings.add("${v.typeName} ${property.name}") return v } operator fun setValue(thisRef: ShaderBuilder, property: KProperty<*>, value: T) { thisRef.varyings.add("${v.typeName} ${property.name}") thisRef.instructions.add(Instruction.assign(property.name, value.value)) } }

GitHub पर शेष प्रतिनिधियों का कार्यान्वयन।

शेडर उदाहरण:

 //    useAlphaTest     , //       , ,  , //   . class FragmentShader(useAlphaTest: Boolean) : ShaderBuilder() { private val alphaTestThreshold by uniform(::GLFloat) private val texture by uniform(::Sampler2D) private val uv by varying(::Vec2) init { var color by vec4() color = texture2D(texture, uv) // static branching if (useAlphaTest) { // dynamic branching If(color.w lt alphaTestThreshold) { discard() } } //     ShaderBuilder. gl_FragColor = color } }

और यहाँ परिणामी GLSL स्रोत (FragmentShader (useAlphaTest = true) .getSource ()) का परिणाम है। कोड की सामग्री और संरचना संरक्षित है:

 uniform sampler2D texture; uniform float alphaTestThreshold; varying vec2 uv; void main(void) { vec4 color; color = texture2D(texture, uv); if ((color.w < alphaTestThreshold)) { discard; } gl_FragColor = color; }

स्रोत को इकट्ठा करते समय विभिन्न मापदंडों को निर्धारित करके shader कोड का पुन: उपयोग करना सुविधाजनक है, लेकिन यह पुन: उपयोग की समस्या को पूरी तरह से हल नहीं करता है। मामले में जब आपको अलग-अलग शेड्स में एक ही कोड लिखने की आवश्यकता होती है, तो आप इन निर्देशों को एक अलग ShaderBuilderComponent में डाल सकते हैं और उन्हें मुख्य ShaderBuilders में आवश्यकतानुसार जोड़ सकते हैं:

 class ShadowReceiveComponent : ShaderBuilderComponent() { … fun vertex(parent: ShaderBuilder, inp: Vec4) { vShadowCoord = shadowMVP * inp ... parent.appendComponent(this) } fun fragment(parent: ShaderBuilder, brightness: GLFloat) { var pixel by float() pixel = texture2D(shadowTexture, vShadowCoord.xy).x ... parent.appendComponent(this) } }

हुर्रे, प्राप्त कार्यक्षमता आपको कोटलिन पर छायांकन लिखने, कोड का पुन: उपयोग करने, वाक्यविन्यास की जांच करने की अनुमति देती है!

अब, चलो GLSL में Swizzling को याद करते हैं और Vec2, Vec3, Vec4 में इसके कार्यान्वयन को देखते हैं।

 class Vec2 { var x by ComponentDelegate(::GLFloat) var y by ComponentDelegate(::GLFloat) } class Vec3 { var x by ComponentDelegate(::GLFloat) ... //  9 Vec2 var xx by ComponentDelegate(::Vec2) var xy by ComponentDelegate(::Vec2) ... } class Vec4 { var x by ComponentDelegate(::GLFloat) ... //  16 Vec2 var xy by ComponentDelegate(::Vec2) ... //  64 Vec3 var xxx by ComponentDelegate(::Vec3) ... }

हमारी परियोजना में, shader संकलन मांग पर खेल चक्र में हो सकता है, और इस तरह के ऑब्जेक्ट आवंटन प्रमुख GC कॉल उत्पन्न करते हैं, लैग्स दिखाई देते हैं। इसलिए, हमने शेडर स्रोतों की असेंबली को एनोटेशन प्रोसेसर का उपयोग करके संकलन चरण में स्थानांतरित करने का निर्णय लिया।

हम श्रेणी को ShaderProgram एनोटेशन के साथ चिह्नित करते हैं:

 @ShaderProgram(VertexShader::class, FragmentShader::class) class ShaderProgramName(alphaTest: Boolean)

और एनोटेशन प्रोसेसर हमारे लिए वर्टेक्स और टुकड़ा वर्गों के निर्माण के मापदंडों के आधार पर सभी प्रकार के शेड्स एकत्र करता है:

 class ShaderProgramNameSources { enum class Sources(vertex: String, fragment: String): ShaderProgramSources { Source0("<vertex code>", "<fragment code>") ... } fun get(alphaTest: Boolean) { if (alphaTest) return Source0 else return Source1 } }

अब आप उत्पन्न वर्ग से shader पाठ प्राप्त कर सकते हैं:

 val sources = ShaderProgramNameSources.get(replaceAlpha = true) println(sources.vertex) println(sources.fragment)

चूँकि प्राप्त फ़ंक्शन का परिणाम - ShaderProgramSource, enum से मान है, इसलिए प्रोग्राम रजिस्ट्री (ShaderProgramSources) -> CompiledShaderProgram में कुंजियों के रूप में इसका उपयोग करना सुविधाजनक है।

गिटहब के पास परियोजना के लिए स्रोत कोड है, जिसमें एनोटेशन प्रोसेसर और शेडर्स और घटकों के सरल उदाहरण शामिल हैं।

कोटलिन पर जीएलएसएल शेड्स का विकास

परियोजना के बारे में

हमारे पास क्या कमी थी

निर्णय

More articles: