/*
आपके द्वारा प्रदान किया गया कोड U8g2 लाइब्रेरी का उपयोग करके विभिन्न आकृतियों और पाठ को चित्रित करने के लिए C/C++ फ़ंक्शंस का एक सेट प्रतीत होता है. U8g2 मोनोक्रोम डिस्प्ले के लिए एक ग्राफिक्स लाइब्रेरी है, जिसका उपयोग आमतौर पर माइक्रोकंट्रोलर और छोटे एम्बेडेड सिस्टम के साथ किया जाता है। आइए प्रत्येक फ़ंक्शन के माध्यम से जाएं और समझाएं कि यह क्या करता है:

void u8g2_prepare(void): यह फ़ंक्शन डिस्प्ले पर ड्राइंग करने से पहले कुछ बुनियादी कॉन्फ़िगरेशन सेट करने के लिए प्रतीत होता है। यह निम्नलिखित करता है:

फ़ॉन्ट को "u8g2_font_6x10_tf" पर सेट करता है.
विस्तारित पाठ के लिए संदर्भ ऊँचाई सेट करता है.
ड्रॉ रंग को 1 पर सेट करता है (जिसका आमतौर पर मतलब सफेद रंग में ड्राइंग होता है)।
फ़ॉन्ट स्थिति को शीर्ष पर सेट करता है.
फ़ॉन्ट दिशा को 0 पर सेट करता है (जिसका अर्थ है क्षैतिज पाठ)।
void u8g2_box_frame(uint8_t a): यह फ़ंक्शन दो बक्से खींचता है और उन्हें लेबल करता है। पैरामीटर का उपयोग बक्से में से एक की स्थिति को समायोजित करने के लिए किया जाता है। फ़ंक्शन निम्न करता है:a

निर्देशांक (0, 0) पर पाठ "ड्राबॉक्स" खींचता है।
5 पिक्सेल की चौड़ाई और 10 पिक्सेल की ऊंचाई के साथ (30, 10) पर एक भरा हुआ बॉक्स खींचता है।
10 पिक्सेल की चौड़ाई और 15 पिक्सेल की ऊंचाई के साथ (30 + ए, 7) पर एक और भरा हुआ बॉक्स खींचता है।
निर्देशांक (0, 30) पर पाठ "ड्राफ़्रेम" खींचता है।
5 पिक्सेल की चौड़ाई और 40 पिक्सेल की ऊंचाई के साथ (20, 10) पर एक फ्रेम (रूपरेखा) खींचता है।
10 पिक्सेल की चौड़ाई और 45 पिक्सेल की ऊंचाई के साथ (30 + ए, 7) पर एक और फ्रेम खींचता है।
void u8g2_disc_circle(uint8_t a): यह फ़ंक्शन लेबल के साथ दो डिस्क और दो सर्कल खींचता है। पैरामीटर का उपयोग डिस्क /सर्कल में से एक की स्थिति को समायोजित करने के लिए किया जाता है। यह निम्नलिखित करता है:a

निर्देशांक (0, 0) पर पाठ "ड्राडिस्क" खींचता है।
10 पिक्सेल की त्रिज्या के साथ (18, 9) पर एक भरी हुई डिस्क खींचता है।
24 पिक्सेल की त्रिज्या के साथ (16 + ए, 7) पर एक और भरी हुई डिस्क खींचता है।
निर्देशांक (0, 30) पर पाठ "ड्रासर्कल" खींचता है।
10 पिक्सेल की त्रिज्या के साथ (48, 9) पर एक वृत्त (रूपरेखा) खींचता है।
24 पिक्सेल की त्रिज्या के साथ (46 + a, 7) पर एक और वृत्त खींचता है।
void u8g2_r_frame(uint8_t a): यह फ़ंक्शन लेबल के साथ एक गोल फ्रेम और एक गोल 
बॉक्स खींचता है। पैरामीटर गोल कोनों की त्रिज्या को नियंत्रित करने के लिए प्रतीत होता है।
 यह निम्नलिखित करता है:a

निर्देशांक (0, 0) पर "ड्रा आरएफरैम / बॉक्स" पाठ खींचता है।
5 पिक्सेल की चौड़ाई, 10 पिक्सेल की ऊंचाई और त्रिज्या के साथ गोल कोनों के साथ (40, 30)
 पर एक गोल फ्रेम खींचता है।a+1
50 पिक्सेल की चौड़ाई, 10 पिक्सेल की ऊंचाई और त्रिज्या के साथ गोल कोनों के साथ (25, 40)
 पर एक गोल बॉक्स खींचता है।a+1
void u8g2_string(uint8_t a): यह फ़ंक्शन विभिन्न कोणों पर पाठ स्ट्रिंग खींचता है। पैरामीटर
 का उपयोग पाठ के रोटेशन कोण को नियंत्रित करने के लिए किया जाता है। यह निम्नलिखित करता है:a

क्षैतिज पाठ खींचने के लिए फ़ॉन्ट दिशा सेट करता है.
निर्देशांक (0 + a, 30) पर एक स्ट्रिंग "31" खींचता है।
ऊर्ध्वाधर पाठ खींचने के लिए फ़ॉन्ट दिशा सेट करता है (90 डिग्री घुमाया गया)।
निर्देशांक (90, 30 + ए) पर एक स्ट्रिंग "31" खींचता है।
180 और 270-डिग्री रोटेशन पर पाठ खींचने के लिए समान चरण।
void u8g2_line(uint8_t a): यह फ़ंक्शन अलग-अलग ढलानों के साथ कई रेखाएं खींचता है। 
पैरामीटर का उपयोग लाइनों के कोण को नियंत्रित करने के लिए किया जाता है। यह निम्नलिखित करता है:a

निर्देशांक (0, 0) पर पाठ "ड्रालाइन" खींचता है।
विभिन्न स्थितियों से शुरू होकर और विभिन्न कोणों के साथ कई रेखाएं खींचता है।
void u8g2_triangle(uint8_t a): यह फलन भिन्न-भिन्न स्थितियों और कोणों वाले त्रिभुज ों को 
खींचता है। पैरामीटर का उपयोग त्रिकोण की स्थिति को समायोजित करने के लिए किया जाता है।
 यह निम्नलिखित करता है:a

निर्देशांक (0, 0) पर पाठ "ड्रा ट्रायंगल" खींचता है।
विभिन्न स्थितियों और कोणों के साथ तीन त्रिभुज बनाता है।
इन फ़ंक्शंस का उपयोग मोनोक्रोम डिस्प्ले पर विभिन्न आकृतियों और पाठ को चित्रित करने 
के लिए U8g2 लाइब्रेरी की क्षमताओं को प्रदर्शित करने के लिए किया जाता है। प्रत्येक फ़ंक्शन में
 पैरामीटर खींची गई वस्तुओं में भिन्नता बनाने के लिए कुछ तत्वों की स्थिति या आकार को नियंत्रित करता है।a
DATE 5 OCT23  
 BY ARVIND PATIL INDIA  THIS PROJECT IS CREATED USING CUSTOM CHIP SH1107
*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif



U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
void u8g2_prepare(void) {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}

void u8g2_box_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawBox");
  u8g2.drawBox(5,10,20,10);
  u8g2.drawBox(10+a,15,30,7);
  u8g2.drawStr( 0, 30, "drawFrame");
  u8g2.drawFrame(5,10+30,20,10);
  u8g2.drawFrame(10+a,15+30,30,7);
}

void u8g2_disc_circle(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawDisc");
  u8g2.drawDisc(10,18,9);
  u8g2.drawDisc(24+a,16,7);
  u8g2.drawStr( 0, 30, "drawCircle");
  u8g2.drawCircle(10,18+30,9);
  u8g2.drawCircle(24+a,16+30,7);
}

void u8g2_r_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawRFrame/Box");
  u8g2.drawRFrame(5, 10,40,30, a+1);
  u8g2.drawRBox(50, 10,25,40, a+1);
}

void u8g2_string(uint8_t a) {
  u8g2.setFontDirection(0);
  u8g2.drawStr(30+a,31, " 0");
  u8g2.setFontDirection(1);
  u8g2.drawStr(30,31+a, " 90");
  u8g2.setFontDirection(2);
  u8g2.drawStr(30-a,31, " 180");
  u8g2.setFontDirection(3);
  u8g2.drawStr(30,31-a, " 270");
}

void u8g2_line(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawLine");
  u8g2.drawLine(7+a, 10, 40, 55);
  u8g2.drawLine(7+a*2, 10, 60, 55);
  u8g2.drawLine(7+a*3, 10, 80, 55);
  u8g2.drawLine(7+a*4, 10, 100, 55);
}

void u8g2_triangle(uint8_t a) {
  uint16_t offset = a;
  u8g2.drawStr( 0, 0, "drawTriangle");
  u8g2.drawTriangle(14,7, 45,30, 10,40);
  u8g2.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);
  u8g2.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);
  u8g2.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);
}

void u8g2_ascii_1() {
  char s[2] = " ";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, "ASCII page 1");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 32;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_ascii_2() {
  char s[2] = " ";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, "ASCII page 2");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 160;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_extra_page(uint8_t a)
{
  u8g2.drawStr( 0, 0, "Unicode");
  u8g2.setFont(u8g2_font_unifont_t_symbols);
  u8g2.setFontPosTop();
  u8g2.drawUTF8(0, 24, "☀ ☁");
  switch(a) {
    case 0:
    case 1:
    case 2:
    case 3:
      u8g2.drawUTF8(a*3, 36, "☂");
      break;
    case 4:
    case 5:
    case 6:
    case 7:
      u8g2.drawUTF8(a*3, 36, "☔");
      break;
  }
}

#define cross_width 24
#define cross_height 24
static const unsigned char cross_bits[] U8X8_PROGMEM  = {
  0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 
  0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80, 
  0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03, 
  0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, };

#define cross_fill_width 24
#define cross_fill_height 24
static const unsigned char cross_fill_bits[] U8X8_PROGMEM  = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26, 
  0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08, 
  0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01, 
  0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04, 
  0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21, 
  0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

#define cross_block_width 14
#define cross_block_height 14
static const unsigned char cross_block_bits[] U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0x01, 0x20, 0xFF, 0x3F, };

void u8g2_bitmap_overlay(uint8_t a) {
  uint8_t frame_size = 28;
 u8g2.drawStr(0, 0, "BY ARVIND PATIL");
  u8g2.drawStr(0, 20, "Bitmap overlay");
delay(1500);
  u8g2.drawStr(0, frame_size + 12, "Solid / transparent");
  u8g2.setBitmapMode(false /* solid */);
  u8g2.drawFrame(0, 10, frame_size, frame_size);
  u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);

  u8g2.setBitmapMode(true /* transparent*/);
  u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);
  u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);
}

void u8g2_bitmap_modes(uint8_t transparent) {
  const uint8_t frame_size = 24;

  u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);
  u8g2.drawStr(frame_size * 0.5, 50, "Black");
  u8g2.drawStr(frame_size * 2, 50, "White");
  u8g2.drawStr(frame_size * 3.5, 50, "XOR");
  
  if(!transparent) {
    u8g2.setBitmapMode(false /* solid */);
    u8g2.drawStr(0, 0, "Solid bitmap");
  } else {
    u8g2.setBitmapMode(true /* transparent*/);
    u8g2.drawStr(0, 0, "Transparent bitmap");
  }
  u8g2.setDrawColor(0);// Black
  u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(1); // White
  u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(2); // XOR
  u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);
}

uint8_t draw_state = 0;

void draw(void) {
  u8g2_prepare();
  switch(draw_state >> 3) {
    case 0: u8g2_box_frame(draw_state&7); break;
    case 1: u8g2_disc_circle(draw_state&7); break;
    case 2: u8g2_r_frame(draw_state&7); break;
    case 3: u8g2_string(draw_state&7); break;
    case 4: u8g2_line(draw_state&7); break;
    case 5: u8g2_triangle(draw_state&7); break;
    case 6: u8g2_ascii_1(); break;
    case 7: u8g2_ascii_2(); break;
    case 8: u8g2_extra_page(draw_state&7); break;
    case 9: u8g2_bitmap_modes(0); break;
    case 10: u8g2_bitmap_modes(1); break;
    case 11: u8g2_bitmap_overlay(draw_state&7); break;
  }
}


void setup(void) {
  u8g2.begin();
}

void loop(void) {
  // picture loop  
  u8g2.clearBuffer();
  draw();
  u8g2.sendBuffer();
  
  // increase the state
  draw_state++;
  if ( draw_state >= 12*8 )
    draw_state = 0;

  // delay between each page
  delay(100);

}