คอมพิวเตอร์กราฟฟิค

จะรู้ได้อย่างไรว่า Bezier ระนาบสองเส้นตัดกัน? โดย "เชื่อถือได้" ฉันหมายถึงการทดสอบจะตอบว่า "ใช่" เฉพาะเมื่อเส้นโค้งตัดกันและ "ไม่" เฉพาะเมื่อไม่ได้ตัดกัน ฉันไม่จำเป็นต้องรู้ว่าพารามิเตอร์ที่จุดตัดพบที่ ฉันยังต้องการใช้ตัวเลขทศนิยมในการดำเนินการ ฉันพบคำตอบหลายคำใน StackOverflow ที่ใช้กล่องขอบเขตของเส้นโค้งสำหรับการทดสอบ: นี่ไม่ใช่สิ่งที่ฉันตามมาเพราะการทดสอบดังกล่าวอาจรายงานจุดตัดแม้ว่าเส้นโค้งจะไม่ตัดกัน สิ่งที่ใกล้เคียงที่สุดที่ฉันพบคือ " ขอบเขตลิ่ม " โดย Sederberg และ Meyers แต่มัน "เท่านั้น" แยกความแตกต่างระหว่างมากที่สุด - หนึ่ง - สองและ - หรือ - สี่แยกมากกว่าในขณะที่ฉันอยากจะรู้ว่ามี - ที่สุด - ศูนย์ และทางแยกอย่างน้อยหนึ่งรายการ

9 computational-geometry  bezier-curve  cad 

การเรนเดอร์สเปกตรัมทั้งหมดถูกจัดการเป็นการจำลองหรือไม่ มีเทคนิคที่ปรับให้เหมาะกับการเรนเดอร์แบบ 'ผู้บริโภค' เช่นแบบเรียลไทม์หรือแม้แต่ 'การมองที่สมจริงโดยไม่ต้องแก้สมการทางกายภาพแบบเต็มรูปแบบ' หรือไม่? ฉันต้องการที่จะเข้าใจวิธีที่เราจัดการกับการแสดงผลของสเปกตรัม ดูเหมือนว่าโฟตอนจะต้องอธิบายว่าเป็นช่วงความยาวคลื่นและมีอุบัติการณ์กับพื้นผิวเช่นกัน แทนที่ต้นฉบับและแก้ไขโฟตอนใหม่หลาย ๆ อันในฟังก์ชั่นสเปคตรัมซึ่งแต่ละอันจะมีเวกเตอร์ใหม่ของตัวเอง รักษาโฟตอนดั้งเดิม (หรือแก้ไขเล็กน้อย) กำหนดขีด จำกัด ฉันอยากจะชี้ไปในทิศทางของงานที่มีอยู่ แต่ชื่นชมสีใด ๆของหัวข้อนี้

9 lighting  photo-realistic  color-science 

คิดเกี่ยวกับไฮบริดเรย์ติงดังนั้นคำถามต่อไปนี้: สมมติว่าฉันมีสองทรงกลมที่เป็นของแข็งและs_2เรารู้ว่าศูนย์กลางและรัศมีของพวกมันและเรารู้ว่าพวกมันมีปริมาตรซ้อนทับกันในอวกาศs1s1s_1s2s2s_2 เรามีการติดตั้งกราฟิก 3 มิติทั่วไป: สมมติตาเป็นจุดเริ่มต้นและเราคาดว่าทรงกลมบนเครื่องบินมุมมองที่สำหรับบางบวกฉทรงกลมอยู่เหนือระนาบมุมมองและไม่ตัดกันz=fz=fz = ffff ให้เป็นวงกลมในอวกาศที่เป็นจุดบนพื้นผิวของทรงกลมทั้งสองนั่นคือ 'การเข้าร่วม' ที่มองเห็นได้ (จากบางมุม) ที่มองเห็นได้ของโวลุ่มที่ทับซ้อนกันccc ฉันต้องการคำนวณว่ามีตัวใด ๆปรากฏเมื่อฉายบนระนาบมุมมองของเราหรือไม่ อาจไม่เป็นเช่นนั้นหากหรือเข้าขวางทางcccs1s1s_1s2s2s_2 มีแนวคิดใดที่จะเข้าใกล้สิ่งนี้?

9 raytracing  3d  occlusion 

ฉันกำลังเรียนหลักสูตรกราฟิกคอมพิวเตอร์ในไตรมาสนี้ หนึ่งในโครงการแล็บของเราเกี่ยวกับการแปลงเป็นซอฟต์แวร์ ตอนนี้ฉันกำลังวางแผนข้อเสนอโครงการและคิดเกี่ยวกับวิธีทำให้เป็นประโยชน์สำหรับผู้อื่นในการพัฒนาเกมร่วมสมัย หลังจากค้นหาสั้น ๆ ฉันได้เรียนรู้เทคนิคที่เรียกว่า Software Occlusion Culling มันทำ rasterization ซอฟต์แวร์บนบัฟเฟอร์ของความละเอียดต่าง ๆ และเราสามารถค้นหาการบดเคี้ยวโดยใช้บัฟเฟอร์ z แบบลำดับชั้น คำถามของฉัน : การใช้ rasterization ของซอฟต์แวร์ในเอ็นจิ้นเกมที่ทันสมัยนอกเหนือจาก Software Occlusion Culling คืออะไร?

9 rendering 

รายการที่แสดงเป็นคุณลักษณะ OpenGL ที่ตามทฤษฎีแล้วสามารถเร่งส่วนใดส่วนหนึ่งของ API โดยการจัดเก็บกลุ่มคำสั่งเพื่อใช้ในภายหลัง ในความเข้าใจของฉันมันมีเหตุผลมากมายเกี่ยวกับความพยายามในปัจจุบันเพื่อลดค่าใช้จ่ายของผู้ขับขี่ รายการที่แสดงถูกคัดค้านในเวอร์ชัน 3.1 แม้ว่า API สมัยใหม่เทียบเท่าอะไรและ DirectX เปิดเผยคุณลักษณะที่คล้ายกัน หากไม่มีฟังก์ชั่นดังกล่าวอีกต่อไปเหตุผลคืออะไร?

9 opengl  display-lists 

ฉันต้องเชื่อมต่อจุดคู่โดยไม่มีทางแยก สมมติว่าฉันมีจุดสองจุดที่ฉันเชื่อมต่อกับส่วนของเส้นโค้ง จากนั้นเลือกจุดปลายทางใหม่สองจุดอีกครั้งและจุดใหม่เหล่านี้จะต้องเชื่อมต่อเช่นกัน วิธีที่ง่ายที่สุดในการค้นหาและวาดส่วนของเส้นโค้งเหล่านี้คืออะไร?

9 algorithm 

ฉันกำลังสำรวจอัลกอริทึม isosurface บน GPU สำหรับโครงการปริญญาตรี ดังนั้นฉันจึงมีการใช้ซีพียูของ marching cubes ที่ดีและทำงานใน OpenFrameworks และตอนนี้อยู่ในขั้นตอนของการพยายามพอร์ตเข้ากับ GLSL compute shaders และพิจารณาข้อผิดพลาดก่อนที่ฉันจะดำดิ่งฉันเขียน Vert และ frag shaders ก่อนหน้านี้มันเป็นเรื่องใหม่สำหรับฉัน ปัญหาแรกของฉันคือวิธีใช้ตารางการค้นหาอย่างมีประสิทธิภาพในหลายสิบหรือหลายร้อยกระทู้ในเวิร์กกรุ๊ป ฉันเข้าใจว่า GPU มีหน่วยความจำประเภทต่าง ๆ สำหรับงานที่แตกต่างกัน แต่ไม่แน่ใจในการทำงานของแต่ละประเภทหรือชนิดที่จะใช้ ตาราง copypasta คลาสสิกของ Paul Bourke เป็นอาร์เรย์ 256 * 16 ดังนั้นหากใช้ชนิดไบต์สเกลาร์สิ่งนี้น่าจะถูกบรรจุลงในพื้นผิว 4kb หรือ SSBO คำถามคือจะหยุดกระทู้ที่แตกต่างกันไม่ให้สะดุดกันได้อย่างไร คิวบ์จำนวนมากในแต่ละกลุ่มงานอาจมีการกำหนดค่าเดียวกันดังนั้นจึงพยายามเข้าถึงตำแหน่งเดียวกันในบัฟเฟอร์ในเวลาเดียวกัน มีวิธีแก้ปัญหาหรือการเพิ่มประสิทธิภาพเพื่อจัดการกับสิ่งนี้หรือไม่?

9 opengl  algorithm  gpgpu  mesh 

สมมติว่าเรามีคอมพิวเตอร์ word-addressable 64- บิตและเราต้องการตั้งโปรแกรมให้แสดงผลตัวอักษร 5x7 ที่จัดเก็บเป็นบิตแมปอิมเมจไบนารี (เช่นด้านล่าง) ไปยังหน่วยความจำที่แมป เนื่องจากเรามี 5 x 7 = 35 พิกเซลต่อตัวอักษรเราจึงสามารถเก็บตัวอักษรโดยใช้ 35 บิตในคำเดียว ด้วยบิตที่มีนัยสำคัญน้อยที่สุดที่เริ่มต้นที่ด้านซ้ายของคำและแต่ละพิกเซลในรูปภาพที่แสดงด้วยบิตที่nดังที่แสดงไว้ด้านบนหมายเลข "3" ด้านบนจะถูกเก็บไว้ในหน่วยความจำดังนี้: 011101000100001001100000110000001111101010 บิตตั้งค่าเป็น 0 นี่เป็นวิธีที่ / ถูกเก็บไว้ในคอมพิวเตอร์เก่า / ทันสมัยหรือไม่? หรือพวกเขาใช้ไบต์เดียว / คำต่อพิกเซลแทน? ถ้ามันถูกเก็บไว้ในลักษณะนี้สิ่งที่รูทีนในแอสเซมบลี / เครื่องรหัส (ใช้อะไรมากไปกว่าคำแนะนำเบื้องต้นเช่นการดำเนินการบิตบิตเลขคณิตและการส่งข้อมูลจาก Instruction Set Architecture ของคอมพิวเตอร์) ที่ใช้ในการแปลงข้อมูลนี้เป็นรูปภาพบน จอแสดงผลเป็นอย่างไร มันจะเป็นเช่น: จัดเก็บพิกัดการแสดงผล x และ y เพื่อให้พิกเซลปัจจุบันได้รับการปรับปรุงในการลงทะเบียนที่แน่นอน เก็บค่า RGB ที่เลือกสองค่า …

9 rendering  2d  bitmap-graphics 

ฉันเขียนโปรแกรมจำลองสถานการณ์ของเหลวตามอนุภาค เป็นการยากที่จะบอกว่าฉันได้รับผลลัพธ์ที่ถูกต้องหรือไม่ ผลลัพธ์ที่มองเห็นได้ดูเหมือนสมเหตุสมผล แต่บางส่วนของมันดูแปลก ฉันไม่รู้ว่ามันเป็นคุณสมบัติของของเหลว มีวิธีที่ถูกต้องในการตรวจสอบว่าโปรแกรมของฉันถูกต้องหรือไม่ แก้ไขรายละเอียดบางอย่าง： โปรแกรมของฉันเป็นโปรแกรมจำลองอนุภาคแบบสองมิติ ของเหลวสามารถบีบอัดได้ การใช้งานเกือบจะขึ้นอยู่กับกระดาษคลาสสิก: Müller, Matthias, David Charypar และ Markus Gross "การจำลองของเหลวตามอนุภาคสำหรับแอปพลิเคชันแบบโต้ตอบ" การดำเนินการของ 2003 ACM SIGGRAPH ฉันแก้ไขสมการเนเวียร์สโตกส์ด้วยวิธีการทำซ้ำ พิจารณาเฉพาะความดัน, แรงโน้มถ่วง, ความหนืดและแรงตึงผิว

9 physics  simulation  fluid-sim 

ก่อนอื่นฉันอยากจะบอกว่าฉันได้อ่านบทความมากมายเกี่ยวกับการทำแผนที่เงาโดยใช้แผนที่ความลึกและ cubemaps และฉันเข้าใจว่ามันทำงานอย่างไรและฉันมีประสบการณ์การทำงานกับพวกเขาด้วยการใช้ OpenGL แต่ฉันมีปัญหาในการใช้งาน เทคนิคการทำแผนที่เงารอบทิศทางโดยใช้แหล่งกำเนิดแสงจุดเดียวในเครื่องมือกราฟิก 3 มิติของฉันชื่อ "EZ3" เอ็นจิ้นของฉันใช้ WebGL เป็น API กราฟิก 3D และ JavaScript เป็นภาษาการเขียนโปรแกรมสำหรับวิทยานิพนธ์ปริญญาตรีสาขาวิทยาศาสตร์คอมพิวเตอร์ โดยทั่วไปนี่คือวิธีที่ฉันใช้อัลกอริทึมการแมปเงาของฉัน แต่ฉันจะเน้นเฉพาะกรณีไฟจุดเพราะพวกเขาสามารถเก็บการแมปเงารอบทิศทาง ครั้งแรกที่ฉันใช้งานการเลือกสรรด้านหน้าแบบนี้: if (this.state.faceCulling !== Material.FRONT) { if (this.state.faceCulling === Material.NONE) gl.enable(gl.CULL_FACE); gl.cullFace(gl.FRONT); this.state.faceCulling = Material.FRONT; } ประการที่สองฉันสร้างโปรแกรมความลึกเพื่อบันทึกค่าความลึกสำหรับใบหน้า cubemap แต่ละอันนี่คือรหัสโปรแกรมความลึกของฉันใน GLSL 1.0: Vertex Shader: precision highp float; attribute vec3 position; uniform …

9 glsl  webgl  shadow-mapping 

แคชทำงานอย่างไรกับการเรนเดอร์แบบเรียงต่อกัน? มีเคล็ดลับเกี่ยวกับวิธีปรับปรุงอัตราส่วนการเข้าชมแคชหรือไม่ (ตัวอย่างเช่นหากไทล์ถูกประมวลผลในแนวนอนและฉันมีเซ็กเมนต์แนวตั้งของรูปสามเหลี่ยมที่มีพื้นผิวเดียวกันมันจะทำงานได้แย่กว่าแคชมากกว่าถ้าฉันมีเลย์เอาต์สามเหลี่ยมออกมาในแนวนอนหรือไม่?)

9 texture  gpu  shader  optimisation 

เมื่อใช้พื้นผิวหลายแบบกับตาข่ายเช่นสำหรับการทำแผนที่ bump ฉันมักจะผูกพื้นผิวกับหน่วยพื้นผิวแบบคงที่ไม่กี่ครั้งแรกเช่น: diffuse = unit 0, bump = unit 1, specular = unit 2 จากนั้นให้นำสิ่งเหล่านั้นกลับมาใช้ใหม่ ตาข่ายที่แตกต่างกันด้วยพื้นผิวที่แตกต่างกัน แต่ฉันสงสัยอยู่เสมอว่าทำไมglActiveTextureสนับสนุนหน่วยพื้นผิวจำนวนมาก (ในลิงค์ก่อนหน้านี้มันบอกว่าอย่างน้อย 80) ดังนั้นสำหรับฉันแล้ววิธีหนึ่งที่เป็นไปได้ในการจัดการพื้นผิวคือการผูกพื้นผิวที่แตกต่างกันสำหรับแต่ละหน่วยที่มีอยู่และปล่อยให้เปิดใช้งานเพียงแค่อัปเดตดัชนีตัวอย่างเครื่องแบบ ที่ควรปรับปรุงการเรนเดอร์เรดิโอโดยการลดจำนวนของสวิทช์พื้นผิว หากคุณมีพื้นผิวน้อยกว่าหน่วยพื้นผิวสูงสุดคุณจะไม่ต้องแยกพื้นผิวออก นี่เป็นแบบฝึกหัดมาตรฐานสำหรับแอปพลิเคชัน OpenGL แบบเรียลไทม์ (ฉันเชื่อว่านี่ใช้กับ D3D ด้วย) และมีนัยใดเกี่ยวกับประสิทธิภาพที่ไม่ชัดเจนของการใช้วิธีนี้หรือไม่? ค่าใช้จ่ายหน่วยความจำอาจจะ?

9 opengl  texture 

ฉันพยายามที่จะเข้าใจเส้นโค้ง NURBS (พื้นผิวในภายหลัง!) แต่ฉันมีปัญหาบางอย่างในการทำความเข้าใจพื้นฐานการทำงานภายในของมัน มีคนช่วยอธิบายสิ่งต่าง ๆ ให้ฉันหน่อยได้ไหม? เมื่อฉันมาจากเส้นโค้ง Bezier การเปรียบเทียบระหว่างสองสิ่งนี้จะเป็นประโยชน์อย่างยิ่ง "ฟังก์ชั่นพื้นฐานที่มีเหตุผล"ดูเหมือนเล็กน้อยเช่น Bernstein พหุนาม (เหตุผล) Bezier โค้ง พารามิเตอร์เปลี่ยนuจาก 0 เป็น 1 หรือไม่ วิธี "เพิ่มรายละเอียด" ลงในกราฟ ฉันหมายถึงด้วยเบซิเยร์ถ้าฉันต้องการอธิบายรูปร่างที่ซับซ้อนมากขึ้นฉันก็แค่ "เย็บ" Beziers หลาย ๆ ตัวเข้าด้วยกัน หรือน้อยกว่านั้นเพิ่มระดับ ฉันเข้าใจว่าฉันสามารถเพิ่มระดับของ NURBS ได้เช่นกันและใส่ NURBS curves หลายแบบเคียงข้างกัน แต่นี่เป็นวิธีที่ควรทำหรือไม่ อย่างน้อยบทความของฉันใน Wikipedia ดูเหมือนจะไม่ชัดเจนเกี่ยวกับ "knot vector" นี้ อะไรกันล่ะ?

9 nurbs 

การเรนเดอร์ไปข้างหน้าเป็นกระบวนการคำนวณค่าความกระจ่างสำหรับชิ้นส่วนพื้นผิวโดยตรงจากเรขาคณิตอินพุตและข้อมูลแสง การเรนเดอร์แบบแยกเป็นการประมวลผลที่แบ่งออกเป็นสองขั้นตอน: ขั้นแรกให้สร้างบัฟเฟอร์พื้นที่หน้าจอที่มีคุณสมบัติของวัสดุ (บัฟเฟอร์เรขาคณิตหรือ G-buffer) ที่สร้างขึ้นโดย rasterizing เรขาคณิตอินพุตและอันดับที่สองสร้างค่าเรเดียนสำหรับแต่ละพิกเซล บัฟเฟอร์ด้วยข้อมูลแสง การเรนเดอร์ที่ถูกเลื่อนมักจะถูกนำเสนอเป็นการปรับการเรนเดอร์ล่วงหน้า คำอธิบายอย่างหนึ่งคือแสงมีราคาค่อนข้างแพงและหากคุณมีการหักเงินมากเกินไปคุณก็จะเป็นพิกเซลแสงที่จะไม่ปรากฏบนหน้าจอในขณะที่ถ้าคุณเก็บคุณสมบัติของวัสดุไว้ใน G-buffer และแสงหลังจากนั้น จริง ๆ แล้วปรากฏบนหน้าจอ นี่เป็นข้อได้เปรียบของการเลื่อนเวลาออกไปหรือไม่เนื่องจากคุณสามารถทำ pre-pass ในระดับลึกได้และจากนั้นจะทำการส่งเรนเดอร์พาสด้วยการทดสอบความลึกที่ตั้งไว้D3D11_COMPARISON_EQUALหรือGL_EQUALหรือเทียบเท่า การเรนเดอร์ยังมีศักยภาพในการกำหนดตารางเวลาที่ดีขึ้นสำหรับ GPU การแยกวาร์ป / คลื่นขนาดใหญ่หนึ่งอันออกเป็นคลื่นเรขาคณิตที่เล็กกว่าจากนั้นแสงคลื่นที่เล็กลงจะช่วยเพิ่มอัตราการเข้าพักได้ในภายหลัง แต่คุณก็จบลงด้วยการใช้แบนด์วิดท์ที่มากขึ้น (เขียนช่องจำนวนมากไปยัง G-buffer แล้วอ่านกลับในช่วงแสง) แน่นอนว่าข้อมูลเฉพาะที่นี่ขึ้นอยู่กับ GPU ของคุณมาก แต่หลักการทั่วไปคืออะไร? มีข้อควรพิจารณาเกี่ยวกับประสิทธิภาพอื่น ๆ เมื่อตัดสินใจระหว่างการเรนเดอร์ไปข้างหน้าและการเรนเดอร์ที่เลื่อนออกไปหรือไม่? (สมมติว่าเราสามารถใช้ความหลากหลายของแต่ละเทคนิคได้หากจำเป็น: เช่นเราสามารถเปรียบเทียบกระเบื้องไปข้างหน้ากับกระเบื้องที่เลื่อนออกไปเช่นกัน)

9 performance  deferred-rendering 

การใช้การเบลอแบบเกาส์หลายครั้งอาจส่งผลให้เกิดผลที่เทียบเท่ากับการเบลอแบบเกาส์ที่แข็งแกร่งกว่า ยกตัวอย่างเช่นคำถามนี้บอกว่า: การทำแบบเกาส์หลายครั้งทำให้พร่ามัวเหมือนกับการทำเบลอที่ใหญ่กว่าหรือไม่? วิกิพีเดียยังบอกด้วยว่ามันบอกว่ามันจะเป็นการคำนวนมากหรือมากกว่านั้นในการทำเบลอหลาย ๆ ครั้งเมื่อเทียบกับการเบลอเพียงครั้งเดียว การประยุกต์ใช้ Gaussian blur หลาย ๆ ภาพที่ต่อเนื่องกันกับภาพจะมีผลเช่นเดียวกับการใช้ gaussian blur ที่ใหญ่กว่าซึ่งมีรัศมีเป็นรากที่สองของผลรวมของกำลังสองของรัศมีการเบลอที่ใช้จริง ตัวอย่างเช่นการใช้ gaussian blurs ที่ต่อเนื่องกับรัศมีของ 6 และ 8 ให้ผลลัพธ์เหมือนกับการใช้ gaussian blur เดียวของรัศมี 10 เนื่องจาก \ sqrt {6 ^ 2 + 8 ^ 2} = 10 เนื่องจากความสัมพันธ์นี้เวลาในการประมวลผลจึงไม่สามารถ ได้รับการบันทึกโดยการจำลอง gaussian blur กับ blurs ที่ต่อเนื่องและน้อยกว่า - เวลาที่ใช้จะน้อยกว่าการแสดง blur ขนาดใหญ่เพียงครั้งเดียว …

9 real-time  gaussian-blur