दिलचस्प पोस्ट
जावास्क्रिप्ट के साथ बेस 64 में द्विआधारी डेटा कन्वर्ट करें एनएटी क्षुधा के लिए लिंकर्स राज्य (उर्फ "कृपा करें, मुझे एक लिंकर मिला है" 2009 संस्करण) सी कार्यक्रम में शेलकोड पांडा: मैं कॉलम में कई पंक्तियों में पाठ कैसे विभाजित करूं? जीडब्ल्यूटी थीम शैली मेरी सीएसएस शैली को ओवरराइड करती है IE के लिए सीएसएस 'पॉइंटर-इवेंट' प्रॉपर्टी विकल्प जावा तिथि वर्ष गणना दो दिनों के लिए बंद है फ़ाइल स्थान से जावा में .exe फ़ाइल चलाएं आईट्यून्स कनेक्ट में ऐप हटाना सीएसएस @ फ़ॉन्ट-चेहरे अर्थात् में काम नहीं कर रहा है कोणीय जेएस: कैसे वादा करने के लिए बाध्य करने के लिए मोंगोडीबी समूह सरणी के आंतरिक तत्वों द्वारा पीडीएफबॉक्स प्रतीक मुद्रा यूरो को सांकेतिक शब्दों में बदलना फोनगैप InAppBrowser प्रदर्शन पीडीएफ 2.7.0 विंडोज 7 पर एसआईपी और पीईएक्टीटी कैसे स्थापित करें I

ओपनग्लैंड में विजुअल सी ++ का उपयोग करके एक 3D क्षेत्र बनाना

मैं OpenGL पुस्तकालय फ़ंक्शन glutSolidSphere () का उपयोग करके C ++ में एक सरल 3D क्षेत्र बनाने में सक्षम नहीं हूँ।

यहां मैंने जो कोशिश की वह है:

#include<GL/glu.h> void display() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,0.0,0.0); glLoadIdentity(); glutSolidSphere( 5.0, 20.0, 20.0); glFlush(); } void myInit() { glClearColor(1.0,1.0,1.0,1.0); glColor3f(1.0,0.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,499.0,0.0,499.0); glMatrixMode(GL_MODELVIEW); } void main(int argc,char **argv) { qobj = gluNewQuadric(); glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(500,500); glutCreateWindow("pendulum"); glutDisplayFunc(display); myInit(); glutMainLoop(); } 

Solutions Collecting From Web of "ओपनग्लैंड में विजुअल सी ++ का उपयोग करके एक 3D क्षेत्र बनाना"

ओपनजीएल में आप ऑब्जेक्ट नहीं बनाते हैं, तो आप उन्हें आकर्षित करते हैं। एक बार जब वे तैयार हो जाते हैं, तो ओपनजीएल अब आपके द्वारा भेजे गए ज्यामिति की परवाह नहीं करता।

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

 #define _USE_MATH_DEFINES #include <GL/gl.h> #include <GL/glu.h> #include <vector> #include <cmath> // your framework of choice here class SolidSphere { protected: std::vector<GLfloat> vertices; std::vector<GLfloat> normals; std::vector<GLfloat> texcoords; std::vector<GLushort> indices; public: SolidSphere(float radius, unsigned int rings, unsigned int sectors) { float const R = 1./(float)(rings-1); float const S = 1./(float)(sectors-1); int r, s; vertices.resize(rings * sectors * 3); normals.resize(rings * sectors * 3); texcoords.resize(rings * sectors * 2); std::vector<GLfloat>::iterator v = vertices.begin(); std::vector<GLfloat>::iterator n = normals.begin(); std::vector<GLfloat>::iterator t = texcoords.begin(); for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) { float const y = sin( -M_PI_2 + M_PI * r * R ); float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R ); float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R ); *t++ = s*S; *t++ = r*R; *v++ = x * radius; *v++ = y * radius; *v++ = z * radius; *n++ = x; *n++ = y; *n++ = z; } indices.resize(rings * sectors * 4); std::vector<GLushort>::iterator i = indices.begin(); for(r = 0; r < rings-1; r++) for(s = 0; s < sectors-1; s++) { *i++ = r * sectors + s; *i++ = r * sectors + (s+1); *i++ = (r+1) * sectors + (s+1); *i++ = (r+1) * sectors + s; } } void draw(GLfloat x, GLfloat y, GLfloat z) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glTranslatef(x,y,z); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexPointer(3, GL_FLOAT, 0, &vertices[0]); glNormalPointer(GL_FLOAT, 0, &normals[0]); glTexCoordPointer(2, GL_FLOAT, 0, &texcoords[0]); glDrawElements(GL_QUADS, indices.size(), GL_UNSIGNED_SHORT, &indices[0]); glPopMatrix(); } }; SolidSphere sphere(1, 12, 24); void display() { int const win_width = …; // retrieve window dimensions from int const win_height = …; // framework of choice here float const win_aspect = (float)win_width / (float)win_height; glViewport(0, 0, win_width, win_height); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45, win_aspect, 1, 10); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); #ifdef DRAW_WIREFRAME glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); #endif sphere.draw(0, 0, -5); swapBuffers(); } int main(int argc, char *argv[]) { // initialize and register your framework of choice here return 0; } 

ऐसा लगता नहीं है कि अब तक किसी ने अपने मूल कोड के साथ वास्तविक समस्या को संबोधित किया है, इसलिए मैंने सोचा कि मैं ऐसा करूँगा, हालांकि इस बिंदु पर प्रश्न काफी पुराना है।

समस्या मूल रूप से त्रिज्या और क्षेत्र की स्थिति के संबंध में प्रक्षेपण के साथ करना था। मुझे लगता है कि आपको लगता है कि समस्या बहुत जटिल नहीं है। कार्यक्रम वास्तव में सही ढंग से काम करता है, यह ठीक है कि जो कुछ किया गया है वह बहुत मुश्किल है।

सबसे पहले, कॉल का उपयोग करके एक ऑर्थोगोनल प्रक्षेपण बनाया गया था

 gluOrtho2D(0.0, 499.0, 0.0, 499.0); 

जो " ग्लोथो को करीब = 1 और दूर = 1 के साथ कॉल करने के बराबर है। " इसका मतलब यह है कि देखने के हताशा में 2 की गहराई है। इसलिए 1 से अधिक कुछ (व्यास = 2) के त्रिज्या वाला क्षेत्र पूरी तरह फिट नहीं होगा देखने के निराशा के भीतर

फिर कॉल

 glLoadIdentity(); glutSolidSphere(5.0, 20.0, 20.0); 

का उपयोग किया जाता है, जो मॉडल-दृश्य मैट्रिक्स की पहचान मैट्रिक्स को लोड करता है और फिर " [आर] मॉडलिंग निर्देशांक पर केन्द्रित एक क्षेत्र को निर्दिष्ट त्रिज्या के मूल निर्देशांक को समाप्त करता है। " अर्थ, क्षेत्र मूल में प्रदान किया जाता है, (एक्स, वाई, z) = (0, 0, 0) और 5 के त्रिज्या के साथ

अब, यह मुद्दा तीन गुना है:

  1. चूंकि खिड़की 500×500 पिक्सल है और देखने के ह्रास की चौड़ाई और ऊंचाई लगभग 500 (49 9 .0) है, क्षेत्र का छोटा त्रिज्या (5.0) इसके अनुमानित क्षेत्र का आकार केवल एक पचासवां (2 * 5/49 9) से थोड़ा अधिक है प्रत्येक आयाम में खिड़की का इसका अर्थ है कि क्षेत्र का स्पष्ट आकार पूरे विंडो के लगभग 1 / 2,500 वें (वास्तव में pi*5^2/499^2 2/49 pi*5^2/499^2 , जो करीब 1/3170 वें के करीब है) हो सकता है , इसलिए यह देखना मुश्किल हो सकता है । यह मान रहा है कि पूरे सर्कल को विंडो के क्षेत्र में तैयार किया गया है। ऐसा नहीं है, हालांकि, जैसा कि हम बिंदु 2 में देखेंगे।
  2. देखने के हताशा के कारण यह एक्स = 0 पर नीचे दिया गया विमान है और y = 0 पर नीचे स्थित है, क्षेत्र को अपने ज्यामितीय केंद्र के साथ विंडो के निचले बाएं कोने में रेंडर किया जाएगा ताकि प्रोजेक्टेड क्षेत्र का केवल एक क्वाड्रंट दिखाई देगा ! इसका अर्थ है कि खिड़की के आकार के बारे में 1/10, 000 (वास्तव में pi*5^2/(4*499^2) , जो कि 1/12, 682 वें के करीब है) भी छोटा होगा। इससे इसे और भी मुश्किल देखना होगा खासकर जब से स्क्रीन को स्क्रीन के किनारों / कोने के करीब पहुंचा दिया जाता है, जहां पर आप नहीं सोचना चाहते हैं
  3. चूंकि देखने के हताशा की गहराई क्षेत्र के व्यास (आधे से कम) की तुलना में काफी कम है, इसलिए केवल क्षेत्र का एक झुकाव देखने के हताशा के भीतर होगा, केवल उस भाग को प्रतिपादित करेगा। तो आपको एक ठोस गोलाकार / मंडल की तुलना में स्क्रीन पर एक खोखले चक्र की तरह अधिक मिलेगा ऐसा होने पर, उस स्लाइडर की मोटाई स्क्रीन पर 1 पिक्सेल से कम का प्रतिनिधित्व कर सकती है, जिसका अर्थ है कि हम स्क्रीन पर कुछ भी नहीं देख सकते, भले ही क्षेत्र का हिस्सा वास्तव में देखने के हताशा में हो।

समाधान केवल क्षेत्र के निराशा और त्रिज्या को देखने के लिए बदलना है। उदाहरण के लिए,

 gluOrtho2D(-5.0, 5.0, -5.0, 5.0); glutSolidSphere(5.0, 20, 20); 

निम्नलिखित चित्र प्रदान करता है

आर = 5.0

जैसा कि आप देख सकते हैं, 5 का त्रिज्या के साथ क्षेत्र के "भूमध्य रेखा" के आसपास केवल एक छोटा सा हिस्सा दिखाई देता है। (मैंने क्षेत्र को गोल के साथ विंडो भरने के लिए प्रोजेक्शन बदल दिया है।) एक अन्य उदाहरण,

 gluOrtho2D(-1.1, 1.1, -1.1, 1.1); glutSolidSphere(1.1, 20, 20); 

निम्नलिखित चित्र प्रदान करता है

आर = 1.1

उपरोक्त छवि देखने के निराशा के अंदर अधिक क्षेत्र दिखाती है, लेकिन फिर भी क्षेत्र में देखने की हताशा की तुलना में 0.2 गहराई इकाइयां हैं। जैसा कि आप देख सकते हैं, क्षेत्र के "बर्फ के ढक्कन" गायब हैं, उत्तर और दक्षिण दोनों में इसलिए, यदि हम चाहते हैं कि पूरे क्षेत्र को गहराई 2 देखने वाले निराशा के भीतर फिट होने दें, तो हमें त्रिज्या 1 से कम या उसके बराबर बनाना चाहिए।

 gluOrtho2D(-1.0, 1.0, -1.0, 1.0); glutSolidSphere(1.0, 20, 20); 

निम्नलिखित चित्र प्रदान करता है

आर = 1.0

मुझे उम्मीद है कि इसने किसी को मदद की है ध्यान रखें!

मुझे समझ में नहीं आ रहा है कि डेटनवोल्फ की इंडेक्स पीढ़ी सही कैसे हो सकती है। लेकिन फिर भी मैं उसका समाधान बल्कि स्पष्ट पता। कुछ सोचने के बाद मुझे यही मिलता है:

 inline void push_indices(vector<GLushort>& indices, int sectors, int r, int s) { int curRow = r * sectors; int nextRow = (r+1) * sectors; indices.push_back(curRow + s); indices.push_back(nextRow + s); indices.push_back(nextRow + (s+1)); indices.push_back(curRow + s); indices.push_back(nextRow + (s+1)); indices.push_back(curRow + (s+1)); } void createSphere(vector<vec3>& vertices, vector<GLushort>& indices, vector<vec2>& texcoords, float radius, unsigned int rings, unsigned int sectors) { float const R = 1./(float)(rings-1); float const S = 1./(float)(sectors-1); for(int r = 0; r < rings; ++r) { for(int s = 0; s < sectors; ++s) { float const y = sin( -M_PI_2 + M_PI * r * R ); float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R ); float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R ); texcoords.push_back(vec2(s*S, r*R)); vertices.push_back(vec3(x,y,z) * radius); push_indices(indices, sectors, r, s); } } } 

यहां कोड है:

 glPushMatrix(); glTranslatef(18,2,0); glRotatef(angle, 0, 0, 0.7); glColor3ub(0,255,255); glutWireSphere(3,10,10); glPopMatrix(); 

मुझे सिक्का का जवाब पसंद है यह समझना सरल है और त्रिकोण के साथ काम करता है हालांकि, अपने कार्यक्रम की अनुक्रमणिका कभी-कभी सीमा से अधिक होती है। इसलिए मैं यहां अपने कोड को दो छोटे सुधारों के साथ पोस्ट करता हूं:

 inline void push_indices(vector<GLushort>& indices, int sectors, int r, int s) { int curRow = r * sectors; int nextRow = (r+1) * sectors; int nextS = (s+1) % sectors; indices.push_back(curRow + s); indices.push_back(nextRow + s); indices.push_back(nextRow + nextS); indices.push_back(curRow + s); indices.push_back(nextRow + nextS); indices.push_back(curRow + nextS); } void createSphere(vector<vec3>& vertices, vector<GLushort>& indices, vector<vec2>& texcoords, float radius, unsigned int rings, unsigned int sectors) { float const R = 1./(float)(rings-1); float const S = 1./(float)(sectors-1); for(int r = 0; r < rings; ++r) { for(int s = 0; s < sectors; ++s) { float const y = sin( -M_PI_2 + M_PI * r * R ); float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R ); float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R ); texcoords.push_back(vec2(s*S, r*R)); vertices.push_back(vec3(x,y,z) * radius); if(r < rings-1) push_indices(indices, sectors, r, s); } } } 

Datenewolf का कोड बिल्कुल सही है। मुझे दोनों घुमावना और नॉर्मल को रिवर्स करना था ताकि यह तय पाइपलाइन के साथ ठीक से काम कर सके। नीचे मेरे लिए चक्कर या सही बंद के साथ काम करता है:

 std::vector<GLfloat> vertices; std::vector<GLfloat> normals; std::vector<GLfloat> texcoords; std::vector<GLushort> indices; float const R = 1./(float)(rings-1); float const S = 1./(float)(sectors-1); int r, s; vertices.resize(rings * sectors * 3); normals.resize(rings * sectors * 3); texcoords.resize(rings * sectors * 2); std::vector<GLfloat>::iterator v = vertices.begin(); std::vector<GLfloat>::iterator n = normals.begin(); std::vector<GLfloat>::iterator t = texcoords.begin(); for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) { float const y = sin( -M_PI_2 + M_PI * r * R ); float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R ); float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R ); *t++ = s*S; *t++ = r*R; *v++ = x * radius; *v++ = y * radius; *v++ = z * radius; *n++ = -x; *n++ = -y; *n++ = -z; } indices.resize(rings * sectors * 4); std::vector<GLushort>::iterator i = indices.begin(); for(r = 0; r < rings-1; r++) for(s = 0; s < sectors-1; s++) { /* *i++ = r * sectors + s; *i++ = r * sectors + (s+1); *i++ = (r+1) * sectors + (s+1); *i++ = (r+1) * sectors + s; */ *i++ = (r+1) * sectors + s; *i++ = (r+1) * sectors + (s+1); *i++ = r * sectors + (s+1); *i++ = r * sectors + s; } 

संपादित करें: यह कैसे आकर्षित करना है पर एक सवाल था … मेरे कोड में मैं इन मानों को जी 3 डी मॉडेल कक्षा में समझाता हूं। यह फ्रेम सेटअप करने, मॉडल खींचने और इसे समाप्त करने के लिए मेरा कोड है:

 void GraphicsProvider3DPriv::BeginFrame()const{ int win_width; int win_height;// framework of choice here glfwGetWindowSize(window, &win_width, &win_height); // retrieve window float const win_aspect = (float)win_width / (float)win_height; // set lighting glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); GLfloat lightpos[] = {0, 0.0, 0, 0.}; glLightfv(GL_LIGHT0, GL_POSITION, lightpos); GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); // set up world transform glClearColor(0.f, 0.f, 0.f, 1.f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT|GL_ACCUM_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45, win_aspect, 1, 10); glMatrixMode(GL_MODELVIEW); } void GraphicsProvider3DPriv::DrawModel(const G3DModel* model, const Transform3D transform)const{ G3DModelPriv* privModel = (G3DModelPriv *)model; glPushMatrix(); glLoadMatrixf(transform.GetOGLData()); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexPointer(3, GL_FLOAT, 0, &privModel->vertices[0]); glNormalPointer(GL_FLOAT, 0, &privModel->normals[0]); glTexCoordPointer(2, GL_FLOAT, 0, &privModel->texcoords[0]); glEnable(GL_TEXTURE_2D); //glFrontFace(GL_CCW); glEnable(GL_CULL_FACE); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, privModel->texname); glDrawElements(GL_QUADS, privModel->indices.size(), GL_UNSIGNED_SHORT, &privModel->indices[0]); glPopMatrix(); glDisable(GL_TEXTURE_2D); } void GraphicsProvider3DPriv::EndFrame()const{ /* Swap front and back buffers */ glDisable(GL_LIGHTING); glDisable(GL_LIGHT0); glDisable(GL_CULL_FACE); glfwSwapBuffers(window); /* Poll for and process events */ glfwPollEvents(); }