การสะท้อนพารามิเตอร์ของ WebGL Shader: การตรวจสอบอินเทอร์เฟซของ Shader

ในขอบเขตของ WebGL และการเขียนโปรแกรมกราฟิกสมัยใหม่ shader reflection หรือที่เรียกว่า shader interface introspection เป็นเทคนิคที่ทรงพลังซึ่งช่วยให้นักพัฒนาสามารถสอบถามข้อมูลเกี่ยวกับโปรแกรม shader ผ่านโค้ดโปรแกรมได้ ข้อมูลเหล่านี้รวมถึงชื่อ ประเภท และตำแหน่งของ uniform variables, attribute variables และองค์ประกอบอินเทอร์เฟซอื่นๆ ของ shader การทำความเข้าใจและใช้ประโยชน์จากการสะท้อน shader สามารถเพิ่มความยืดหยุ่น การบำรุงรักษา และประสิทธิภาพของแอปพลิเคชัน WebGL ได้อย่างมาก คู่มือฉบับสมบูรณ์นี้จะเจาะลึกถึงความซับซ้อนของการสะท้อน shader สำรวจประโยชน์ การนำไปใช้ และการประยุกต์ใช้งานจริง

Shader Reflection คืออะไร?

โดยแก่นแท้แล้ว shader reflection คือกระบวนการวิเคราะห์โปรแกรม shader ที่คอมไพล์แล้วเพื่อดึงข้อมูลเมทาเดตา (metadata) เกี่ยวกับอินพุตและเอาต์พุตของมัน ใน WebGL, shaders จะถูกเขียนด้วยภาษา GLSL (OpenGL Shading Language) ซึ่งเป็นภาษาคล้าย C ที่ออกแบบมาโดยเฉพาะสำหรับหน่วยประมวลผลกราฟิก (GPUs) เมื่อ GLSL shader ถูกคอมไพล์และเชื่อมโยงเข้ากับโปรแกรม WebGL ตัว WebGL runtime จะเก็บข้อมูลเกี่ยวกับอินเทอร์เฟซของ shader ไว้ ซึ่งรวมถึง:

• Uniform Variables: ตัวแปรโกลบอลภายใน shader ที่สามารถแก้ไขได้จากโค้ด JavaScript มักใช้เพื่อส่งผ่านค่าเมทริกซ์, เท็กซ์เจอร์, สี และพารามิเตอร์อื่นๆ ไปยัง shader
• Attribute Variables: ตัวแปรอินพุตที่ส่งไปยัง vertex shader สำหรับแต่ละ vertex โดยทั่วไปจะแสดงถึงตำแหน่งของ vertex, normals, texture coordinates และข้อมูลอื่นๆ แบบ per-vertex
• Varying Variables: ตัวแปรที่ใช้ส่งข้อมูลจาก vertex shader ไปยัง fragment shader ค่าเหล่านี้จะถูกประมาณค่า (interpolated) ไปทั่ว primitive ที่ถูกแรสเตอร์ไรซ์
• Shader Storage Buffer Objects (SSBOs): พื้นที่หน่วยความจำที่ shader สามารถเข้าถึงได้เพื่ออ่านและเขียนข้อมูลใดๆ ก็ได้ (เพิ่มเข้ามาใน WebGL 2)
• Uniform Buffer Objects (UBOs): คล้ายกับ SSBOs แต่โดยทั่วไปใช้สำหรับข้อมูลแบบอ่านอย่างเดียว (read-only) (เพิ่มเข้ามาใน WebGL 2)

Shader reflection ช่วยให้เราสามารถดึงข้อมูลนี้ผ่านโค้ดโปรแกรมได้ ทำให้เราสามารถปรับโค้ด JavaScript ของเราให้ทำงานกับ shader ที่แตกต่างกันได้โดยไม่ต้องฮาร์ดโค้ด (hardcoding) ชื่อ ประเภท และตำแหน่งของตัวแปรเหล่านี้ ซึ่งมีประโยชน์อย่างยิ่งเมื่อทำงานกับ shader หรือไลบรารี shader ที่โหลดแบบไดนามิก

ทำไมต้องใช้ Shader Reflection?

Shader reflection มีข้อดีที่น่าสนใจหลายประการ:

การจัดการ Shader แบบไดนามิก

เมื่อพัฒนาแอปพลิเคชัน WebGL ขนาดใหญ่หรือซับซ้อน คุณอาจต้องการโหลด shader แบบไดนามิกตามข้อมูลที่ผู้ใช้ป้อน, ความต้องการของข้อมูล หรือความสามารถของฮาร์ดแวร์ Shader reflection ช่วยให้คุณสามารถตรวจสอบ shader ที่โหลดเข้ามาและกำหนดค่าพารามิเตอร์อินพุตที่จำเป็นได้โดยอัตโนมัติ ทำให้แอปพลิเคชันของคุณมีความยืดหยุ่นและปรับตัวได้มากขึ้น

ตัวอย่าง: ลองนึกภาพแอปพลิเคชันสร้างโมเดล 3 มิติที่ผู้ใช้สามารถโหลดวัสดุ (materials) ต่างๆ ที่มีความต้องการ shader ที่แตกต่างกันได้ ด้วยการใช้ shader reflection แอปพลิเคชันสามารถระบุเท็กซ์เจอร์, สี และพารามิเตอร์อื่นๆ ที่จำเป็นสำหรับ shader ของวัสดุแต่ละชนิดและผูก (bind) ทรัพยากรที่เหมาะสมได้โดยอัตโนมัติ

การนำโค้ดกลับมาใช้ใหม่และการบำรุงรักษา

ด้วยการแยกโค้ด JavaScript ของคุณออกจากการใช้งาน shader ที่เฉพาะเจาะจง shader reflection จะส่งเสริมการนำโค้ดกลับมาใช้ใหม่และการบำรุงรักษา คุณสามารถเขียนโค้ดทั่วไปที่ทำงานกับ shader ได้หลากหลาย ลดความจำเป็นในการเขียนโค้ดแยกตาม shader แต่ละตัว และทำให้การอัปเดตและแก้ไขง่ายขึ้น

ตัวอย่าง: พิจารณา rendering engine ที่รองรับโมเดลแสงหลายแบบ แทนที่จะเขียนโค้ดแยกสำหรับแต่ละโมเดลแสง คุณสามารถใช้ shader reflection เพื่อผูกพารามิเตอร์แสงที่เหมาะสมโดยอัตโนมัติ (เช่น ตำแหน่งแสง, สี, ความเข้ม) ตาม shader แสงที่เลือก

การป้องกันข้อผิดพลาด

Shader reflection ช่วยป้องกันข้อผิดพลาดโดยให้คุณสามารถตรวจสอบได้ว่าพารามิเตอร์อินพุตของ shader ตรงกับข้อมูลที่คุณกำลังส่งให้หรือไม่ คุณสามารถตรวจสอบประเภทข้อมูลและขนาดของ uniform และ attribute variables และแจ้งเตือนหรือแสดงข้อผิดพลาดหากมีความไม่ตรงกัน ซึ่งช่วยป้องกันการแสดงผลที่ผิดพลาด (rendering artifacts) หรือการแครชที่ไม่คาดคิด

การเพิ่มประสิทธิภาพ

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

Shader Reflection ทำงานอย่างไรใน WebGL

WebGL ไม่มี API สำหรับ reflection ในตัวเหมือนกับ API กราฟิกอื่นๆ (เช่น program interface queries ของ OpenGL) ดังนั้น การใช้งาน shader reflection ใน WebGL จึงต้องใช้เทคนิคผสมผสานกัน โดยหลักๆ แล้วคือการแยกวิเคราะห์ (parsing) ซอร์สโค้ด GLSL หรือใช้ไลบรารีภายนอกที่ออกแบบมาเพื่อการนี้โดยเฉพาะ

การแยกวิเคราะห์ซอร์สโค้ด GLSL

วิธีที่ตรงไปตรงมาที่สุดคือการแยกวิเคราะห์ซอร์สโค้ด GLSL ของโปรแกรม shader ซึ่งเกี่ยวข้องกับการอ่านซอร์สโค้ดของ shader เป็นสตริง แล้วใช้นิพจน์ปรกติ (regular expressions) หรือไลบรารีการแยกวิเคราะห์ที่ซับซ้อนกว่าเพื่อระบุและดึงข้อมูลเกี่ยวกับ uniform variables, attribute variables และองค์ประกอบอื่นๆ ที่เกี่ยวข้องของ shader

ขั้นตอนที่เกี่ยวข้อง:

1. ดึงซอร์สโค้ด Shader: ดึงซอร์สโค้ด GLSL จากไฟล์, สตริง หรือแหล่งข้อมูลบนเครือข่าย
2. แยกวิเคราะห์ซอร์สโค้ด: ใช้นิพจน์ปรกติหรือตัวแยกวิเคราะห์ GLSL เฉพาะเพื่อระบุการประกาศของ uniforms, attributes และ varyings
3. ดึงข้อมูล: ดึงชื่อ, ประเภท และ qualifier ที่เกี่ยวข้อง (เช่น `const`, `layout`) สำหรับตัวแปรที่ประกาศแต่ละตัว
4. จัดเก็บข้อมูล: จัดเก็บข้อมูลที่ดึงมาได้ในโครงสร้างข้อมูลเพื่อใช้ในภายหลัง โดยทั่วไปจะเป็นอ็อบเจกต์หรืออาร์เรย์ของ JavaScript

ตัวอย่าง (โดยใช้นิพจน์ปรกติ):

            function reflectShader(shaderSource) {
  const uniforms = [];
  const attributes = [];

  // Regular expression to match uniform declarations
  const uniformRegex = /uniform\s+([^\s]+)\s+([^\s;]+)\s*;/g;
  let match;
  while ((match = uniformRegex.exec(shaderSource)) !== null) {
    uniforms.push({
      type: match[1],
      name: match[2],
    });
  }

  // Regular expression to match attribute declarations
  const attributeRegex = /attribute\s+([^\s]+)\s+([^\s;]+)\s*;/g;
  while ((match = attributeRegex.exec(shaderSource)) !== null) {
    attributes.push({
      type: match[1],
      name: match[2],
    });
  }

  return {
    uniforms: uniforms,
    attributes: attributes,
  };
}

// Example usage:
const vertexShaderSource = `
  attribute vec3 a_position;
  attribute vec2 a_texCoord;

  uniform mat4 u_modelViewProjectionMatrix;
  varying vec2 v_texCoord;

  void main() {
    gl_Position = u_modelViewProjectionMatrix * vec4(a_position, 1.0);
    v_texCoord = a_texCoord;
  }
`;

const reflectionData = reflectShader(vertexShaderSource);
console.log(reflectionData);

            

              
                Copy
              
            
          

ข้อจำกัด:

• ความซับซ้อน: การแยกวิเคราะห์ GLSL อาจซับซ้อน โดยเฉพาะอย่างยิ่งเมื่อต้องจัดการกับ preprocessor directives, คอมเมนต์ และโครงสร้างข้อมูลที่ซับซ้อน
• ความแม่นยำ: นิพจน์ปรกติอาจไม่แม่นยำเพียงพอสำหรับโครงสร้าง GLSL ทั้งหมด ซึ่งอาจนำไปสู่ข้อมูล reflection ที่ไม่ถูกต้อง
• การบำรุงรักษา: ตรรกะการแยกวิเคราะห์จำเป็นต้องได้รับการอัปเดตเพื่อรองรับฟีเจอร์และไวยากรณ์ใหม่ๆ ของ GLSL

การใช้ไลบรารีภายนอก

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

ตัวอย่างไลบรารี:

• glsl-parser: ไลบรารี JavaScript สำหรับการแยกวิเคราะห์ซอร์สโค้ด GLSL มันให้การแสดงผลของ shader ในรูปแบบ abstract syntax tree (AST) ทำให้ง่ายต่อการวิเคราะห์และดึงข้อมูล
• shaderc: ชุดเครื่องมือคอมไพเลอร์สำหรับ GLSL (และ HLSL) ที่สามารถส่งออกข้อมูล reflection ในรูปแบบ JSON ได้ แม้ว่าวิธีนี้จะต้องคอมไพล์ shader ล่วงหน้า แต่ก็สามารถให้ข้อมูลที่แม่นยำมาก

ขั้นตอนการทำงานกับไลบรารีการแยกวิเคราะห์:

1. ติดตั้งไลบรารี: ติดตั้งไลบรารีการแยกวิเคราะห์ GLSL ที่เลือกโดยใช้ตัวจัดการแพ็คเกจ เช่น npm หรือ yarn
2. แยกวิเคราะห์ซอร์สโค้ด Shader: ใช้ API ของไลบรารีเพื่อแยกวิเคราะห์ซอร์สโค้ด GLSL
3. สำรวจ AST: สำรวจ abstract syntax tree (AST) ที่สร้างขึ้นโดยตัวแยกวิเคราะห์เพื่อระบุและดึงข้อมูลเกี่ยวกับ uniform variables, attribute variables และองค์ประกอบอื่นๆ ที่เกี่ยวข้องของ shader
4. จัดเก็บข้อมูล: จัดเก็บข้อมูลที่ดึงมาได้ในโครงสร้างข้อมูลเพื่อใช้ในภายหลัง

ตัวอย่าง (โดยใช้ตัวแยกวิเคราะห์ GLSL สมมติ):

            // Hypothetical GLSL parser library
const glslParser = { parse: function(source) { /* ... */ } };

function reflectShaderWithParser(shaderSource) {
  const ast = glslParser.parse(shaderSource);
  const uniforms = [];
  const attributes = [];

  // Traverse the AST to find uniform and attribute declarations
  ast.traverse(node => {
    if (node.type === 'UniformDeclaration') {
      uniforms.push({
        type: node.dataType,
        name: node.identifier,
      });
    } else if (node.type === 'AttributeDeclaration') {
      attributes.push({
        type: node.dataType,
        name: node.identifier,
      });
    }
  });

  return {
    uniforms: uniforms,
    attributes: attributes,
  };
}

// Example usage:
const vertexShaderSource = `
  attribute vec3 a_position;
  attribute vec2 a_texCoord;

  uniform mat4 u_modelViewProjectionMatrix;
  varying vec2 v_texCoord;

  void main() {
    gl_Position = u_modelViewProjectionMatrix * vec4(a_position, 1.0);
    v_texCoord = a_texCoord;
  }
`;

const reflectionData = reflectShaderWithParser(vertexShaderSource);
console.log(reflectionData);

            

              
                Copy
              
            
          

ข้อดี:

• ความแข็งแกร่ง: ไลบรารีการแยกวิเคราะห์มีความสามารถในการแยกวิเคราะห์ที่แข็งแกร่งและแม่นยำกว่าการใช้นิพจน์ปรกติด้วยตนเอง
• ใช้งานง่าย: ไลบรารีมี API ระดับสูงที่ทำให้กระบวนการตรวจสอบ shader ง่ายขึ้น
• การบำรุงรักษา: โดยทั่วไปไลบรารีจะได้รับการบำรุงรักษาและอัปเดตเพื่อรองรับฟีเจอร์และไวยากรณ์ใหม่ๆ ของ GLSL

การประยุกต์ใช้งานจริงของ Shader Reflection

Shader reflection สามารถนำไปประยุกต์ใช้กับแอปพลิเคชัน WebGL ได้หลากหลายประเภท รวมถึง:

ระบบวัสดุ (Material Systems)

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

ตัวอย่าง: game engine สามารถใช้ shader reflection เพื่อกำหนดอินพุตเท็กซ์เจอร์ที่จำเป็นสำหรับวัสดุแบบ Physically Based Rendering (PBR) เพื่อให้แน่ใจว่าเท็กซ์เจอร์ albedo, normal, roughness และ metallic ที่ถูกต้องถูกผูกเข้ากับแต่ละวัสดุ

ระบบแอนิเมชัน

เมื่อทำงานกับ skeletal animation หรือเทคนิคแอนิเมชันอื่นๆ shader reflection สามารถใช้เพื่อผูกเมทริกซ์ของกระดูก (bone matrices) หรือข้อมูลแอนิเมชันอื่นๆ ที่เหมาะสมกับ shader ได้โดยอัตโนมัติ ซึ่งทำให้กระบวนการสร้างแอนิเมชันสำหรับโมเดล 3 มิติที่ซับซ้อนง่ายขึ้น

ตัวอย่าง: ระบบแอนิเมชันตัวละครสามารถใช้ shader reflection เพื่อระบุ uniform array ที่ใช้เก็บเมทริกซ์ของกระดูก และอัปเดตอาร์เรย์โดยอัตโนมัติด้วยการแปลงค่า (transformations) ของกระดูกในปัจจุบันสำหรับแต่ละเฟรม

เครื่องมือดีบัก (Debugging Tools)

Shader reflection สามารถใช้เพื่อสร้างเครื่องมือดีบักที่ให้ข้อมูลโดยละเอียดเกี่ยวกับโปรแกรม shader เช่น ชื่อ, ประเภท และตำแหน่งของ uniform variables และ attribute variables สิ่งนี้มีประโยชน์สำหรับการระบุข้อผิดพลาดหรือการเพิ่มประสิทธิภาพของ shader

ตัวอย่าง: WebGL debugger สามารถแสดงรายการของ uniform variables ทั้งหมดใน shader พร้อมกับค่าปัจจุบันของมัน ทำให้นักพัฒนาสามารถตรวจสอบและแก้ไขพารามิเตอร์ของ shader ได้อย่างง่ายดาย

การสร้างเนื้อหาแบบมีกระบวนการ (Procedural Content Generation)

Shader reflection ช่วยให้ระบบสร้างเนื้อหาแบบมีกระบวนการสามารถปรับตัวเข้ากับ shader ใหม่หรือที่แก้ไขแล้วได้แบบไดนามิก ลองนึกภาพระบบที่ shader ถูกสร้างขึ้นทันทีตามข้อมูลที่ผู้ใช้ป้อนหรือเงื่อนไขอื่นๆ Reflection ช่วยให้ระบบเข้าใจความต้องการของ shader ที่สร้างขึ้นเหล่านี้โดยไม่จำเป็นต้องกำหนดไว้ล่วงหน้า

ตัวอย่าง: เครื่องมือสร้างภูมิประเทศอาจสร้าง shader ที่กำหนดเองสำหรับชีวนิเวศ (biomes) ที่แตกต่างกัน Shader reflection จะช่วยให้เครื่องมือเข้าใจว่าต้องส่งเท็กซ์เจอร์และพารามิเตอร์ใด (เช่น ระดับหิมะ, ความหนาแน่นของต้นไม้) ไปยัง shader ของแต่ละชีวนิเวศ

ข้อควรพิจารณาและแนวทางปฏิบัติที่ดีที่สุด

แม้ว่า shader reflection จะมีประโยชน์อย่างมาก แต่ก็เป็นเรื่องสำคัญที่ต้องพิจารณาประเด็นต่อไปนี้:

ค่าใช้จ่ายด้านประสิทธิภาพ (Performance Overhead)

การแยกวิเคราะห์ซอร์สโค้ด GLSL หรือการสำรวจ AST อาจใช้ทรัพยากรในการคำนวณสูง โดยเฉพาะสำหรับ shader ที่ซับซ้อน โดยทั่วไปแนะนำให้ทำการสะท้อน shader เพียงครั้งเดียวเมื่อโหลด shader และแคช (cache) ผลลัพธ์ไว้เพื่อใช้ในภายหลัง หลีกเลี่ยงการทำการสะท้อน shader ภายใน rendering loop เพราะอาจส่งผลกระทบอย่างมากต่อประสิทธิภาพ

ความซับซ้อน

การใช้งาน shader reflection อาจมีความซับซ้อน โดยเฉพาะเมื่อต้องจัดการกับโครงสร้าง GLSL ที่ซับซ้อนหรือใช้ไลบรารีการแยกวิเคราะห์ขั้นสูง สิ่งสำคัญคือต้องออกแบบตรรกะการสะท้อนของคุณอย่างระมัดระวังและทดสอบอย่างละเอียดเพื่อให้แน่ใจว่ามีความแม่นยำและแข็งแกร่ง

ความเข้ากันได้ของ Shader

Shader reflection อาศัยโครงสร้างและไวยากรณ์ของซอร์สโค้ด GLSL การเปลี่ยนแปลงซอร์สโค้ดของ shader อาจทำให้ตรรกะการสะท้อนของคุณใช้งานไม่ได้ ตรวจสอบให้แน่ใจว่าตรรกะการสะท้อนของคุณมีความแข็งแกร่งพอที่จะรับมือกับการเปลี่ยนแปลงในโค้ดของ shader หรือจัดเตรียมกลไกสำหรับการอัปเดตเมื่อจำเป็น

ทางเลือกใน WebGL 2

WebGL 2 มีความสามารถในการตรวจสอบภายในที่จำกัดเมื่อเทียบกับ WebGL 1 แม้ว่าจะไม่ใช่ API การสะท้อนที่สมบูรณ์ คุณสามารถใช้ `gl.getActiveUniform()` และ `gl.getActiveAttrib()` เพื่อรับข้อมูลเกี่ยวกับ uniforms และ attributes ที่ถูกใช้งานจริงโดย shader อย่างไรก็ตาม วิธีนี้ยังคงต้องการทราบดัชนี (index) ของ uniform หรือ attribute ซึ่งโดยทั่วไปต้องมีการฮาร์ดโค้ดหรือการแยกวิเคราะห์ซอร์สโค้ดของ shader วิธีการเหล่านี้ยังไม่ได้ให้รายละเอียดมากเท่ากับที่ API การสะท้อนเต็มรูปแบบจะให้ได้

การแคชและการเพิ่มประสิทธิภาพ

ดังที่ได้กล่าวไปแล้ว ควรทำการสะท้อน shader เพียงครั้งเดียวและแคชผลลัพธ์ไว้ ข้อมูลที่สะท้อนควรถูกจัดเก็บในรูปแบบที่มีโครงสร้าง (เช่น อ็อบเจกต์ JavaScript หรือ Map) ที่ช่วยให้สามารถค้นหาตำแหน่งของ uniform และ attribute ได้อย่างมีประสิทธิภาพ

บทสรุป

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