3D रेंडरिंग और ट्रांसफ़ॉर्मेशन के लिए मुफ्त गो लाइब्रेरी

FauxGL के साथ शुरुआत

FauxGL स्थापित करने का अनुशंसित तरीका GitHub का उपयोग करना है। सुगम स्थापना के लिए कृपया निम्न कमांड का उपयोग करें।

go get github.com/fogleman/fauxgl 

Go API के माध्यम से शुद्ध CPU-आधारित रेंडरिंग

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

import "github.com/fogleman/fauxgl"

const (
    width  = 1024
    height = 768
)

func main() {
    context := fauxgl.NewContext(width, height)
    context.ClearColorBufferWithColor(fauxgl.Black)
    context.ClearDepthBuffer()

    // Now you can start drawing models or primitives!
}

3D मॉडल लोडिंग और रूपांतरण

ओपन सोर्स FauxGL लाइब्रेरी ने Go एप्लिकेशन के भीतर 3D मॉडल लोड करने और उनके साथ काम करने के लिए पूर्ण समर्थन प्रदान किया है। एक बार लोड हो जाने पर, आप आसानी से स्केलिंग, रोटेशन, रिसाइज़िंग और ट्रांसलेशन जैसे रूपांतरण लागू कर सकते हैं। यहाँ एक सरल उदाहरण दिया गया है जो दिखाता है कि सॉफ़्टवेयर डेवलपर्स Wavefront OBJ फ़ॉर्मेट, जो सबसे सामान्य 3D मॉडल फ़ाइल फ़ॉर्मेट्स में से एक है, को कैसे लोड कर सकते हैं और Go लाइब्रेरी का उपयोग करके उस पर रूपांतरण लागू कर सकते हैं।

mesh, err := fauxgl.LoadOBJ("model.obj")
if err != nil {
    panic(err)
}

// Apply transformations
matrix := fauxgl.Identity().
    Scale(fauxgl.Vector{1, 1, 1}).
    Rotate(fauxgl.V(0, 1, 0), fauxgl.Radians(45)).
    Translate(fauxgl.Vector{0, 0, -5})

mesh.Transform(matrix)

Go लाइब्रेरी के माध्यम से वेक्टर संचालन

MathGL लाइब्रेरी वेक्टर और मैट्रिक्स गणित के लिए व्यापक समर्थन प्रदान करती है, जिसमें 2D, 3D, और 4D वेक्टर और मैट्रिक्स के ऑपरेशन शामिल हैं। ये स्थितियों, दिशाओं, वेगों और अन्य स्थानिक डेटा को संभालने के लिए आवश्यक हैं। यह Add, Sub, Dot, Cross, Normalize आदि और कई प्रिसीजन प्रकारों (float32 के लिए mgl32, float64 के लिए mgl64) का समर्थन करती है। यहाँ एक सरल उदाहरण है जो दर्शाता है कि सॉफ़्टवेयर डेवलपर्स अपने Go एप्लिकेशन में विभिन्न वेक्टर ऑपरेशन्स कैसे कर सकते हैं।

package main

import (
	"fmt"
	"github.com/go-gl/mathgl/mgl32"
)

func main() {
	// Create two 3D vectors
	v1 := mgl32.Vec3{1, 2, 3}
	v2 := mgl32.Vec3{4, 5, 6}

	// Vector addition
	sum := v1.Add(v2)
	fmt.Println("Vector sum:", sum) // [5 7 9]

	// Dot product
	dot := v1.Dot(v2)
	fmt.Println("Dot product:", dot) // 32

	// Cross product
	cross := v1.Cross(v2)
	fmt.Println("Cross product:", cross) // [-3 6 -3]
}

Go के माध्यम से कस्टम शेडिंग और सामग्री

आप Go एप्लिकेशन के भीतर कस्टमाइज़ेबल शेडर्स का उपयोग करके वस्तुओं को शेड करने का तरीका परिभाषित कर सकते हैं। ओपन सोर्स FauxGL लाइब्रेरी आपके अपने शेडिंग लॉजिक को लिखने के लिए एक लचीला सिस्टम प्रदान करती है — जिससे आप रंग, प्रकाश, और यहाँ तक कि पिक्सेल स्तर पर कस्टम इफ़ेक्ट्स को नियंत्रित कर सकते हैं। निम्नलिखित दिखाता है कि सॉफ़्टवेयर डेवलपर्स Go एप्लिकेशन में सरल फ्लैट शेडिंग कैसे कर सकते हैं।

shader := func(vertex fauxgl.Vertex) fauxgl.Color {
    normal := vertex.Normal.Normalize()
    light := fauxgl.Vector{1, 1, 1}.Normalize()
    intensity := normal.Dot(light)
    baseColor := fauxgl.HexColor(0x3498db) // Light blue color
    return baseColor.MulScalar(intensity)
}

context.Shader = shader
context.DrawMesh(mesh)