libGDX - परिप्रेक्ष्य कैमरा और दृश्य का क्षेत्र

Question

मुझे libGDX में परिप्रेक्ष्य कैमरे के दृश्य को समझने में समस्याएं हैं (या शायद मेरी गणना गलत है)।

मैं एक बॉक्स बनाना चाहता हूं (उदाहरण के लिए 800px चौड़ा, 480px उच्च और 20px गहरा)। बॉक्स एक्स- और वाई-अक्ष के बीच रखा गया है (दूसरे शब्दों में: एक्स-अक्ष पर चौड़ाई और वाई-अक्ष पर ऊंचाई)। अब मैं एक्स-अक्ष (कैमरा स्थिति) पर बॉक्स के पीछे खड़ा होना चाहता हूं और इस तरह से एक दिशा में देखना चाहता हूं कि मैं अपने बहुत ही सही स्क्रीन पक्ष पर बॉक्स देखता हूं। मैं कुछ रेखाचित्र बनाया:

पिछले स्केच पर, बॉक्स दृश्य के क्षेत्र के दाईं ओर है।

इसके अलावा, बॉक्स की ऊंचाई स्क्रीन में बिल्कुल फिट होना चाहिए। दूसरे शब्दों में: बॉक्स का शीर्ष किनारा मेरे स्क्रीन टॉप पर होना चाहिए और बॉक्स के निचले किनारे को मेरे स्क्रीन तल पर होना चाहिए। यहाँ कुछ कोड और गणना इस लक्ष्य को हासिल करने के लिए है:

public class Box implements ApplicationListener { 

public PerspectiveCamera camera; 
public float SCREEN_WIDTH; 
public float SCREEN_HEIGHT; 

@Override 
public void create() { 
    SCREEN_WIDTH = Gdx.graphics.getWidth(); // 800px 
    SCREEN_HEIGHT = Gdx.graphics.getHeight(); // 480px 

    // Create camera (90°) and set position 
    camera = new PerspectiveCamera(90f, SCREEN_WIDTH, SCREEN_HEIGHT); 
    camera.position.set(SCREEN_WIDTH + SCREEN_HEIGHT/2, SCREEN_HEIGHT/2, 0f); 
    camera.lookAt(0f, SCREEN_HEIGHT/2, 0f); 
    camera.near = 1; 
    camera.far = 2 * SCREEN_WIDTH; 
    camera.update(); 
} 

@Override 
public void render() { 
    Gdx.gl.glClearColor(Color.WHITE.r, Color.WHITE.g, Color.WHITE.b, Color.WHITE.a); 
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT); 

    // Build the box - width is screenwidth and height is screenheight - one corner in origin 
    ModelBuilder modelBuilder = new ModelBuilder(); 
    modelBuilder.begin(); 
    MeshPartBuilder mpb = modelBuilder.part("ID", GL20.GL_TRIANGLES, Usage.Position | Usage.Normal, 
      new Material(ColorAttribute.createDiffuse(Color.GREEN))); 
    // bottom left corner of the box should be in (0,0,0) 
    mpb.box(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, -10f, SCREEN_WIDTH, SCREEN_HEIGHT, 20f); 
    Model model = modelBuilder.end(); 
    ModelInstance instance = new ModelInstance(model); 

    // Build some light 
    Environment environment = new Environment(); 
    environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1f)); 
    environment.add(new DirectionalLight().set(0.8f, 0.8f, 0.8f, -1f, -0.8f, -0.2f)); 

    // Draw the box 
    ModelBatch modelBatch = new ModelBatch(); 
    modelBatch.begin(camera); 
    modelBatch.render(instance, environment); 
    modelBatch.end(); 
} 
} 

, स्क्रीन में बॉक्स ऊंचाई मैं पीछे हटना चाहिए SCREEN_HEIGHT/2 फिट क्योंकि एक्स = SCREEN_HEIGHT/2/तन (45 °) = SCREEN_HEIGHT/2/1 = SCREEN_HEIGHT/2, यही कारण है कि मैंने इस लंबाई को स्थिति सेटिंग में एक्स-घटक में जोड़ा।

कोड स्केच 2 का प्रतिनिधित्व करता है और मुझे लगता है कि सही स्क्रीनशॉट दे:

आदेश स्केच 3 प्राप्त करने के लिए, मैं बाईं ओर देखने की मेरी क्षेत्र बारी बारी से करना चाहिए के बारे में 45 डिग्री। लेकिन इस संबंध में मुझे थोड़ा पीछे हटना चाहिए, क्योंकि दृश्य क्षेत्र के किनारे केंद्र रेखा से अधिक लंबे समय तक हैं।

कहाँ ज = SCREEN_HEIGHT: मैं दो हाथों से बनाए गए रेखाचित्र बनाया है। सबसे पहले, मुझे एक्स की गणना करना है। एक्स = एच/2/पाप (45 डिग्री) = एच/वर्ग (2)। अब मुझे एक्स की लंबाई वापस लेनी चाहिए और एक नई दिशा में देखना चाहिए (बॉक्स से 45 डिग्री बाएं)। बिंदु है जिस पर मैं देख होगा गणना करने के लिए, मैं इस स्केच पर लंबाई y गणना:

y = पाप (45 °) * ज/2 = ज * sqrt (2)/4। तो, बिंदु उदाहरण के लिए है (SCREEN_WIDTH + (x-y), SCREEN_HEIGHT/2, y)। अब मैं अपने कोड में स्थिति और देख बिंदु बदल:

public void create() { 
    SCREEN_WIDTH = Gdx.graphics.getWidth(); // 800px 
    SCREEN_HEIGHT = Gdx.graphics.getHeight(); // 480px 

    // Create camera (90°) and set position 
    camera = new PerspectiveCamera(90f, SCREEN_WIDTH, SCREEN_HEIGHT); 
    float x = (float) (SCREEN_HEIGHT/Math.sqrt(2)); 
    float y = (float) (SCREEN_HEIGHT * Math.sqrt(2)/4f); 
    camera.position.set(SCREEN_WIDTH + x, SCREEN_HEIGHT/2, 0f); 
    camera.lookAt(SCREEN_WIDTH + x - y, SCREEN_HEIGHT/2, y); 
    camera.near = 1; 
    camera.far = 2 * SCREEN_WIDTH; 
    camera.update(); 
} 

और मैं इस स्क्रीन मिलती है:

लेकिन बॉक्स बहुत दाईं ओर :(

पर नहीं है

तो अब सवाल: क्या गलत है? क्या देखने के क्षेत्र में मेरी सोच गलत है या मेरी गणना?

सर्वश्रेष्ठ संबंध!

Answer 1

PerspectiveCamera की आपकी समझ थोड़ा सा है, विशेष रूप से यह दूसरे (viewportWidth) और तीसरे (viewportHeight) तर्क के साथ क्या करता है।

एकमात्र चीज PerspectiveCamera उनके साथ पहलू अनुपात प्राप्त करती है और projectionMatrix सेट करने के लिए इसका उपयोग करती है। विशिष्ट कोड के लिए यह this line देखता है जो पहलू अनुपात और this method की गणना करता है जो projectionMatrix सेट करता है।

अब यह सब ठीक है और अच्छा है, सिवाय इसके कि आप पहलू अनुपात से निपटने के लिए गणित भी करते हैं, और इसे दो बार करने से कैमरा फिर से फैलता है। समाधान काफी सरल है, या तो अपने गणित फिर से करना पहलू अनुपात के लिए समायोजित नहीं करने के लिए या

camera = new PerspectiveCamera(90f, 1, 1); 

साथ

camera = new PerspectiveCamera(90f, SCREEN_WIDTH, SCREEN_HEIGHT); 

की जगह पहलू अनुपात है कि libgdx गणना 1 हो बनाने के लिए।

मैं साइन और कोसाइन के साथ इतना अच्छा नहीं हूं इसलिए मैं पहले विकल्प के समाधान प्रदान नहीं कर सकता, लेकिन आपको मुश्किल गणित के साथ कोई समस्या नहीं लगती है।