อะไรคือเส้นโค้งที่พบได้บ่อยที่สุดในการพัฒนาเกม

แสดงรายการ splines ทั่วไปที่พบในการพัฒนาเกมจำนวนจุดที่วิธีการจำเป็นต้องสอดแทรกเส้นโค้งและวิธีสร้างชนิดข้อมูลที่ช่วยให้คุณได้รับการแก้ไขจุดโค้ง ตัวอย่าง: เส้นโค้ง Bezier, B-Splines, Cubic Splines ฯลฯ

PS: ฉันวางสิ่งนี้เป็นวิกิชุมชนเพื่อให้เราสามารถแสดงรายการการแก้ไขอิสระทุกชนิด

กรณีที่ง่ายที่สุดคือการแก้ไขเชิงเส้นสำหรับเส้นตรง:

(x0, y0) * ------------------------ * (x1, y1)

พูดว่า t อยู่ระหว่าง [0, 1]:

function lerp((x0, y0), (x1, y1), t):
    return (x0+(x1-x0)*t, y0+(y1-y0)*t)

Catmull-Rom splines (ประเภทของลูกบาศก์ hermite spline) จะมีประโยชน์มากถ้าคุณมีชุดของจุดที่คุณต้องการสร้างเส้นทางที่ราบรื่นระหว่าง (โดยไม่กำหนดจุดควบคุมเพิ่มเติมใด ๆ ) เช่นเส้นทางกล้อง

สำหรับคณิตศาสตร์ทั้งหมดดู:

http://en.wikipedia.org/wiki/Cubic_Hermite_spline

หากคุณใช้ D3DX มีฟังก์ชั่นที่ใช้งานง่ายสำหรับจัดการกับมัน (D3DXVec3CatmullRom)

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

ฉันสร้างภูมิประเทศ 3 มิติที่เรียบง่ายจากนั้นต้องการให้ตัวละครของฉันเดินข้ามภูมิประเทศ ดังนั้นเพื่อค้นหาความสูงของตัวละคร ณ จุดใด ๆ บนภูมิประเทศฉันใช้การแก้ไขแบบสองทาง

นี่คือรหัส Java ที่ฉันใช้สำหรับการแก้ไข bilinear:

/**
 * Interpolates the value of a point in a two dimensional surface using bilinear spline interpolation.
 * The value is calculated using the position of the point and the values of the 4 surrounding points.
 * Note that the returned value can be more or less than any of the values of the surrounding points. 
 * 
 * @param p A 2x2 array containing the heights of the 4 surrounding points
 * @param x The horizontal position, between 0 and 1
 * @param y The vertical position, between 0 and 1
 * @return the interpolated height
 */
private static float bilinearInterpolate (float[][] p, float x, float y) {
    return p[0][0]*(1.0f-x)*(1.0f-y) + p[1][0]*x*(1.0f-y) + p[0][1]*(1.0f-x)*y + p[1][1]*x*y;
}

/**
 * Finds a 2-dimensional array of the heights of the four points that 
 * surround (x,y).
 *
 * Uses the member variable "verts", an 2D array of Vertex objects which have
 * a member "height" that is the specific vertex's height.
 */
private float[][] nearestFour(float x, float y) {
    int xf = (int) Math.floor(x);
    int yf = (int) Math.floor(y);

    if(xf < 0 || yf < 0 || xf > verts[0].length-2 || yf > verts.length-2) {
        // TODO do something better than just return 0s
        return new float[][]{
                {0.0f, 0.0f},
                {0.0f, 0.0f}
            };
    } else {
        return new float[][]{
                {verts[yf][xf].height, verts[yf][xf+1].height},
                {verts[yf+1][xf].height, verts[yf+1][xf+1].height},
            };
    }
}

โปรดทราบว่าการแก้ไขแบบ bicubic อาจทำให้การแก้ไขราบรื่นขึ้นหรือสมจริงยิ่งขึ้นในจุดที่ห่างไกล แต่ฉันเลือกที่จะไปกับ bilinear เพราะฉันมีตารางหนาแน่นในความพยายามที่จะเพิ่มประสิทธิภาพ (อาจก่อนกำหนด)