โดยพื้นฐานแล้วบิตแมป 2D จะแสดงผลอย่างไร

สมมติว่าเรามีคอมพิวเตอร์ word-addressable 64- บิตและเราต้องการตั้งโปรแกรมให้แสดงผลตัวอักษร 5x7 ที่จัดเก็บเป็นบิตแมปอิมเมจไบนารี (เช่นด้านล่าง) ไปยังหน่วยความจำที่แมป

เนื่องจากเรามี 5 x 7 = 35 พิกเซลต่อตัวอักษรเราจึงสามารถเก็บตัวอักษรโดยใช้ 35 บิตในคำเดียว ด้วยบิตที่มีนัยสำคัญน้อยที่สุดที่เริ่มต้นที่ด้านซ้ายของคำและแต่ละพิกเซลในรูปภาพที่แสดงด้วยบิตที่nดังที่แสดงไว้ด้านบนหมายเลข "3" ด้านบนจะถูกเก็บไว้ในหน่วยความจำดังนี้: 011101000100001001100000110000001111101010 บิตตั้งค่าเป็น 0

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

ถ้ามันถูกเก็บไว้ในลักษณะนี้สิ่งที่รูทีนในแอสเซมบลี / เครื่องรหัส (ใช้อะไรมากไปกว่าคำแนะนำเบื้องต้นเช่นการดำเนินการบิตบิตเลขคณิตและการส่งข้อมูลจาก Instruction Set Architecture ของคอมพิวเตอร์) ที่ใช้ในการแปลงข้อมูลนี้เป็นรูปภาพบน จอแสดงผลเป็นอย่างไร มันจะเป็นเช่น:

1. จัดเก็บพิกัดการแสดงผล x และ y เพื่อให้พิกเซลปัจจุบันได้รับการปรับปรุงในการลงทะเบียนที่แน่นอน
2. เก็บค่า RGB ที่เลือกสองค่า (ในกรณีนี้คือ 0,255,0 สำหรับสีเขียวและสีดำ 0,0,0 สำหรับ 0,0) ในการลงทะเบียนอีกสองแบบแยกกัน
3. ให้รีจิสเตอร์เพิ่มเติมสองตัวทำหน้าที่เป็นตัวนับเริ่มต้นเป็น 5 และ 7 เพื่อติดตามแถวและคอลัมน์ปัจจุบันของอิมเมจที่ถูกเรนเดอร์
4. ทดสอบว่าการลงทะเบียนคอลัมน์ไม่ใช่ 0 หรือไม่ถ้าไม่ใช่ให้ทดสอบว่า LSB ของบิตแมปถูกตั้งค่าเป็น 1 จากนั้นและการลงทะเบียนค่า RGB ที่เกี่ยวข้องกับการลงทะเบียนพิกัด x และ y ขึ้นอยู่กับผลลัพธ์แล้ว MOV ที่เป็นผลลัพธ์ เพื่อลงทะเบียนเอาต์พุตการแสดงผล
5. ลดการลงทะเบียนตัวนับแถวลง 1 ทดสอบเพื่อดูว่าเป็น 0 หรือไม่ถ้าใช่ให้ตั้งค่ากลับเป็น 5 และเพิ่มพิกัด y เป็น 1 และเพิ่มตัวนับคอลัมน์ที่ 1 ลง
6. เลื่อนรีจิสเตอร์ที่ถือบิตแมป 1 บิตไปทางซ้าย
7. JMP ถึงคำสั่ง 4

มีวิธีที่ง่ายขึ้นหรือมีประสิทธิภาพมากขึ้นในการทำเช่นนี้? ดูเหมือนว่าแม้จะเป็นอะไรที่เรียบง่ายเหมือนกับการเรนเดอร์ตัวอักษรขนาดเล็กเพียงตัวเดียว แต่ก็มีการใช้งานจำนวนมากและอาจใช้เวลาประมาณ 200 รอบ CPU

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

คุณต้องแยกความแตกต่างของข้อความและโหมดกราฟิกของบอร์ดกราฟิกของเครื่อง

ในสมัยก่อนส่วนใหญ่รองรับโหมดข้อความ ในโหมดนี้คณะกรรมการจะดูแลการจัดเก็บนิยามบิตแมปของตัวละครและแสดงไว้ที่ตำแหน่งเคอร์เซอร์ปัจจุบัน สิ่งที่คุณต้องทำคือให้รหัส ASCII ของตัวละคร (หนึ่งไบต์ต่อตัวอักษร) ในบัฟเฟอร์ข้อความขนาดเล็ก

ทุกวันนี้มีการให้บัฟเฟอร์แรสเตอร์ความละเอียดสูงซึ่งสามารถเข้าถึงพิกเซลได้และคุณเขียนข้อมูลสีในรูปแบบที่รองรับบางรูปแบบ (ในโหมด "สูงสุด", 3 ไบต์ (RGB) ต่อพิกเซลสำหรับพิกเซลหรือมากกว่า)

ในขั้นต้นมีการใช้บิตแมปไบนารีที่เรียบง่าย (บรรจุ) ขนาดแตกต่างกันและ " blittted " ไปยังหน่วยความจำแรสเตอร์ผ่านการร้องขอไปยังไดรเวอร์อุปกรณ์ที่มีการแปลรูปแบบที่เป็นไปได้

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

เอาต์พุตที่เรนเดอร์สามารถถูกแคชเพื่อการแสดงผลที่รวดเร็วอีกครั้งโดยการตัด

กระบวนการโดยรวมมีความซับซ้อนสามารถเร่งความเร็วฮาร์ดแวร์และจัดการโดยระบบปฏิบัติการ (การจัดการ GUI) ในวิธีที่โปร่งใสพร้อมกับการดำเนินการวาดแบบกราฟิกดั้งเดิมอื่น ๆ

คำตอบสั้น ๆ คือใช่คุณไม่สามารถหลีกเลี่ยงการจัดการบิตจำนวนมากหากรูปแบบของคุณต้องการ

การวาดบิตแมปโดยทั่วไปหมายถึงการคัดลอกพิกเซลจากแหล่งไปยังปลายทางและคุณต้องทำสิ่งที่ต้องทำ (การอ้างอิงกัปตันชัดเจน)

คำตอบที่ยาวกว่าคือถ้าคุณเขียน rasterizer ซอฟต์แวร์คุณสามารถมีอัลกอริธึมและกลอุบายเพื่อช่วยคุณประหยัดเวลาของซีพียู (โดยการรู้ว่าส่วนใดที่คุณไม่จำเป็นต้องวาด (การเพิ่มประสิทธิภาพความโปร่งใส) โดยมีรูปแบบพิกเซล ในฐานะปลายทาง (โดยตรงหรือในรูปแบบของแคช), ทำการ memcopy ได้ดีที่สุด, ... โดยทั่วไปให้พิจารณาการวาดวนรอบของแรสเตอร์เซอร์ของคุณและดูว่าคุณสามารถปรับโครงสร้างเหล่านั้นเพื่อประหยัดเวลาของ CPU ได้อย่างไร (เช่น: คุณสามารถสร้างรันไทม์ ชิ้นส่วนของรหัสแอสเซมเบลอร์เพื่อพิมพ์ตัวอักษร A หรือให้เมตาไปยังแหล่งข้อมูลบิตแมปของคุณเพื่อบอกวิธีข้ามพื้นที่โปร่งใส ฯลฯ ) กรณีการใช้งานแต่ละกรณีอาจมีวิธีการแก้ปัญหาที่แตกต่างกันตามชุดคำสั่ง CPU รูปแบบบัฟเฟอร์ อัลกอริทึมของการเรนเดอร์เรนเดอร์ของคุณ (การหมุนหรือการยืดบิตแมปการกรองชนิดใด ฯลฯ ... ) การลงทะเบียน CPU และแคชเป็นต้น

ดังนั้นใช่แล้วมันใช้วงจรซีพียูจำนวนมากเพื่อเขียนพิกเซลเดียวในสมัยก่อนเมื่อการเข้ารหัสแปลก ๆ และหน่วยความจำขนาดเล็กเป็นบรรทัดฐาน :-) แต่มันไม่ได้ห้ามเครื่อง 16/32 บิตที่มี CPU 8 เมกะเฮิร์ตซ์ที่จะทำสิ่งเช่นนั้น: https://www.youtube.com/watch?v=GWwPJU6pp30 (และยังใช้ CPU ขนาดใหญ่อีกด้วย สำหรับเพลง)

ในกรณีของการเรนเดอร์ HW HW จะทำการแปลงจากรูปแบบต้นฉบับเป็นรูปแบบปลายทางและในขณะที่มันจะไม่ใช้กลอุบายมากมายสำหรับ SW rasterizer การใช้งานทั่วไปใน HW จะเป็นไปได้สูงกว่าการใช้ SW เกือบทั้งหมด