['   \n  \n [ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਹੇਠ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲੋਃ ਕਾਂਸਟ ਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; \\nਕੌਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; \\n\\nਕੌਂਸਟਫਲੋਟ R1 = 1; \\nਕੋਨਸਟ ਫਲੋਟ R2 = 2; \\nਕੋਨਸਟ ਫਲੋਟ K2 = 5; \\n// ਸਕਰੀਨ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ K1 ਦੀ ਗਣਨਾ ਕਰੋ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਲਗਭਗ ਕਿਨਾਰੇ ਉੱਤੇ \\n// ਹੁੰਦੀ ਹੈ।ਟੋਰਸ ਦਾ, ਜੋ ਕਿ x = R1 + R2 ਉੱਤੇ ਹੈ, z = 0. ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ ਦੇ 3/8ਵੇਂ ਹਿੱਸੇ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇ, ਜੋ ਕਿ ਤੋਂ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈਸਕਰੀਨ ਦੇ ਪਾਸੇ ਦਾ ਕੇਂਦਰ। \\n// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0) \\n// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 \\nਕੌਂਸਟ ਫਲੋਟ K1 =ਸਕਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)); \\n\\nrender _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ A ਅਤੇ B ਦੀਆਂ ਕੋਸਾਇਨਾਂ = cos (A), sinA =sin (A); \\n ਫਲੋਟ cosB = cos (B), sinB = sin (B); \\n\\n ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ ਉਚਾਈ] = \'; \\n ਫਲੋਟ zbuffer [0. ਸਕ੍ਰੀਨ ਚੌਡ਼ਾਈ,0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0; \\n\\n// ਥੀਟਾ ਇੱਕ ਟੋਰਸ ਦੇ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਚੱਕਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ <2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {\\n//ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਕੋਸਾਈਨਾਂ ਦੇ ਥੀਟਾ \\n ਫਲੋਟ ਕੌਸਥੇਟਾ = ਕੋਸ (ਥੀਟਾ), ਸਿੰਥੇਟਾ = ਸਾਈਨ (ਥੀਟਾ); \\n\\n// ਫਾਈ ਇੱਕ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ।ਟੋਰਸ \\n ਲਈ (ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਫਾਈ ਦੀ ਕੋਸਾਈਨਾਂ\\ਨ ਫਲੋਟ ਕੌਸਫੀ = ਕੋਸ (ਫਾਈ), ਸਿਨਫੀ = ਸਾਈਨ (ਫਾਈ); \\n//ਚੱਕਰ ਦਾ x, y ਨਿਰਦੇਸ਼ਾਂਕ, ਘੁੰਮਣ ਤੋਂ ਪਹਿਲਾਂ (ਉੱਪਰ ਦਿੱਤੀਆਂ ਸਮੀਕਰਨਾਂ ਵਿੱਚੋਂ ਫੈਕਟੋਰਡ \\n//) \\n ਫਲੋਟ ਚੱਕਰ = R2 + R1 * ਕੌਸਥੀਟਾ; \\n ਫਲੋਟ ਚੱਕਰ =R1 * ਸਿੰਥੇਟਾ; \\n\\n// ਅੰਤਿਮ 3D (x, y, z) ਸਡ਼ਨ ਤੋਂ ਬਾਅਦ ਨਿਰਦੇਸ਼ਾਂਕ "] ', "ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਹੇਠ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲੋਃ ਕਾਂਸਟ ਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; ਕਾਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; ਕਾਂਸਟ ਫਲੋਟR1 = 1; ਕਾਂਸਟ ਫਲੋਟ R2 = 2; ਕਾਂਸਟ ਫਲੋਟ K2 = 5;// ਸਕਰੀਨ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ K1 ਦੀ ਗਣਨਾ ਕਰੋ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਲਗਭਗ ਦੇ ਕਿਨਾਰੇ ਉੱਤੇ// ਹੁੰਦੀ ਹੈ।ਟੋਰਸ, ਜੋ ਕਿ x = R1 + R2, z = 0 ਉੱਤੇ ਹੈ. ਅਸੀਂ// ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ ਦੇ 3/8ਵੇਂ ਹਿੱਸੇ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇ, ਜੋ ਕਿ// ਕੇਂਦਰ ਤੋਂ ਦੂਜੇ ਪਾਸੇ ਤੱਕ ਦੇ ਰਸਤੇ ਦਾ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈ।ਸਕਰੀਨ ਦੇ ਪਾਸੇ.// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0)// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 ਸਥਿਰ ਫਲੋਟ K1 = ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2));ਰੈਂਡਰ _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {// A ਅਤੇ B ਫਲੋਟ ਦੀਆਂ ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਕੋਸਾਈਨਾਂ cosA = cos (A), sinA = sin (A); ਫਲੋਟ cosB = cos (B), sinB = sin (B);ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = '; ਫਲੋਟ ਜ਼ਬਫਰ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0;// ਥੀਟਾ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈਇੱਕ ਟੋਰਸ ਦਾ ਚੱਕਰ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ <2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਥੀਟਾ ਫਲੋਟ ਕੋਸਥੀਟਾ = ਕੋਸ (ਥੀਟਾ) ਦੀਆਂ ਕੋਸਾਈਨਾਂ ਲਈ,ਸਿੰਥੇਟਾ = sin (ਥੀਟਾ);// ਫਾਈ ਇੱਕ ਟੋਰਸ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ)ਅਤੇ ਫਾਈ ਫਲੋਟ ਕੌਸਫ਼ੀ ਦੀਆਂ ਕੋਸਾਈਨਾਂ = ਕੌਸ (ਫਾਈ), ਸਿਨਫੀ = ਸਾਈਨ (ਫਾਈ);// ਚੱਕਰ ਦਾ x, y ਨਿਰਦੇਸ਼ਾਂਕ, ਘੁੰਮਣ ਤੋਂ ਪਹਿਲਾਂ (ਉੱਪਰ ਦਿੱਤੇ ਤੱਤਾਂ ਵਿੱਚੋਂ ਕਾਰਕ// ਬਾਹਰ)ਸਮੀਕਰਨਾਂ) ਫਲੋਟ ਚੱਕਰ = R2 + R1 * ਕੋਸਥੀਟਾ; ਫਲੋਟ ਚੱਕਰ = R1 * ਸਿੰਥੀਟਾ;// ਅੰਤਿਮ 3D (x, y, z) ਸਡ਼ਨ ਤੋਂ ਬਾਅਦ ਨਿਰਦੇਸ਼ਾਂਕ", ' [ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਹੇਠ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲੋਃ ਕਾਂਸਟ ਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; \\nਕੌਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; \\n\\nਕੌਂਸਟਫਲੋਟ R1 = 1; \\nਕੋਨਸਟ ਫਲੋਟ R2 = 2; \\nਕੋਨਸਟ ਫਲੋਟ K2 = 5; \\n// ਸਕਰੀਨ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ K1 ਦੀ ਗਣਨਾ ਕਰੋ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਲਗਭਗ ਕਿਨਾਰੇ ਉੱਤੇ \\n// ਹੁੰਦੀ ਹੈ।ਟੋਰਸ ਦਾ, ਜੋ ਕਿ x = R1 + R2 ਉੱਤੇ ਹੈ, z = 0. ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ ਦੇ 3/8ਵੇਂ ਹਿੱਸੇ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇ, ਜੋ ਕਿ ਤੋਂ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈਸਕਰੀਨ ਦੇ ਪਾਸੇ ਦਾ ਕੇਂਦਰ। \\n// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0) \\n// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 \\nਕੌਂਸਟ ਫਲੋਟ K1 =ਸਕਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)); \\n\\nrender _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ A ਅਤੇ B ਦੀਆਂ ਕੋਸਾਇਨਾਂ = cos (A), sinA =sin (A); \\n ਫਲੋਟ cosB = cos (B), sinB = sin (B); \\n\\n ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ ਉਚਾਈ] = \'; \\n ਫਲੋਟ zbuffer [0. ਸਕ੍ਰੀਨ ਚੌਡ਼ਾਈ,0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0; \\n\\n// ਥੀਟਾ ਇੱਕ ਟੋਰਸ ਦੇ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਚੱਕਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ <2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {\\n//ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਕੋਸਾਈਨਾਂ ਦੇ ਥੀਟਾ \\n ਫਲੋਟ ਕੌਸਥੇਟਾ = ਕੋਸ (ਥੀਟਾ), ਸਿੰਥੇਟਾ = ਸਾਈਨ (ਥੀਟਾ); \\n\\n// ਫਾਈ ਇੱਕ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ।ਟੋਰਸ \\n ਲਈ (ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਫਾਈ ਦੀ ਕੋਸਾਈਨਾਂ\\ਨ ਫਲੋਟ ਕੌਸਫੀ = ਕੋਸ (ਫਾਈ), ਸਿਨਫੀ = ਸਾਈਨ (ਫਾਈ); \\n//ਚੱਕਰ ਦਾ x, y ਨਿਰਦੇਸ਼ਾਂਕ, ਘੁੰਮਣ ਤੋਂ ਪਹਿਲਾਂ (ਉੱਪਰ ਦਿੱਤੀਆਂ ਸਮੀਕਰਨਾਂ ਵਿੱਚੋਂ ਫੈਕਟੋਰਡ \\n//) \\n ਫਲੋਟ ਚੱਕਰ = R2 + R1 * ਕੌਸਥੀਟਾ; \\n ਫਲੋਟ ਚੱਕਰ =R1 * ਸਿੰਥੇਟਾ; \\n\\n// ਫਾਈਨਲ 3D (x, y, z) ਸਡ਼ਨ ਤੋਂ ਬਾਅਦ ਤਾਲਮੇਲ ਕਰਦਾ ਹੈ, "" ਯਕੀਨਨ, ਇੱਥੇ ਸੋਧਿਆ ਹੋਇਆ ਕੋਡ ਹੈ ਜੋ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲਦਾ ਹੈਃ \\n "\'scsss\\nonstਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; \\nਕੌਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; \\n\\nਕੌਂਸਟ ਫਲੋਟ R1 = 1; \\nਕੌਂਸਟ ਫਲੋਟ R2 = 2; \\nਕੌਂਸਟ ਫਲੋਟ K2 = 5; \\n\\n// K1 ਅਧਾਰਤ ਗਣਨਾ ਕਰੋਆਨ ਸਕਰੀਨ ਸਾਈਜ਼ਃ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਟੋਰਸ ਦੇ ਕਿਨਾਰੇ \'ਤੇ ਲਗਭਗ \\n// ਹੁੰਦੀ ਹੈ, ਜੋ ਕਿ x = R1 + R2, z = 0\' ਤੇ ਹੁੰਦੀ ਹੈ।ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ, ਜੋ ਕਿ ਕੇਂਦਰ ਤੋਂ ਸਕ੍ਰੀਨ ਦੇ ਪਾਸੇ ਤੱਕ ਦਾ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈ। \\n// ਸਕ੍ਰੀਨ ਦੀ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0) \\n//ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 \\nਕੌਂਸਟ ਫਲੋਟ K1 = ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)); \\n\\nrender _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇA ਅਤੇ B ਦੀਆਂ ਕੋਸਾਇਨਾਂ ਫਲੋਟ cosA = cos (A), sinA = sin (A); \\n ਫਲੋਟ cosB = cos (B), sinB = sin (B); \\n\\n ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ _ ਵਿਡਥ, 0. ਸਕ੍ਰੀਨ _ ਹਾਈਟ] = \'\'; \\n ਫਲੋਟ ਜ਼ਬਫਰ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0; \\n\\n// ਥੀਟਾ ਇੱਕ ਟੋਰਸ ਦੇ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਚੱਕਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ ਲਈ<2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਥੀਟਾ ਦੀਆਂ ਕੋਸਾਈਨਾਂ \\n ਫਲੋਟ ਕੌਸਥੇਟਾ = ਕੋਸ (ਥੀਟਾ), ਸਿੰਥੇਟਾ = ਸਾਈਨ (ਥੀਟਾ); \\n\\n// ਫਾਈ ਜਾਂਦਾ ਹੈ(ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ) ਲਈ ਇੱਕ ਟੋਰਸ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ।ਕੋਸਫ਼ੀ = ਕੋਸ (ਫਾਈ), ਸਿਨਫ਼ੀ = ਸਾਈਨ (ਫਾਈ); \\n\\n/x, y ਚੱਕਰ ਦਾ ਨਿਰਦੇਸ਼ਾਂਕ, ", \'ਮੈਂ ਇਸ ਕੋਡ ਨੂੰ ਕੰਮ ਕਰਦੇ ਵੇਖਣ ਲਈ ਕਿੱਥੇ ਚਲਾ ਸਕਦਾ ਹਾਂ? ', "ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਹੇਠ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲੋਃ ਕਾਂਸਟ ਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; ਕਾਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; ਕਾਂਸਟ ਫਲੋਟR1 = 1; ਕਾਂਸਟ ਫਲੋਟ R2 = 2; ਕਾਂਸਟ ਫਲੋਟ K2 = 5;// ਸਕਰੀਨ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ K1 ਦੀ ਗਣਨਾ ਕਰੋ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਲਗਭਗ ਦੇ ਕਿਨਾਰੇ ਉੱਤੇ// ਹੁੰਦੀ ਹੈ।ਟੋਰਸ, ਜੋ ਕਿ x = R1 + R2, z = 0 ਉੱਤੇ ਹੈ. ਅਸੀਂ// ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ ਦੇ 3/8ਵੇਂ ਹਿੱਸੇ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇ, ਜੋ ਕਿ// ਕੇਂਦਰ ਤੋਂ ਦੂਜੇ ਪਾਸੇ ਤੱਕ ਦੇ ਰਸਤੇ ਦਾ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈ।ਸਕਰੀਨ ਦੇ ਪਾਸੇ.// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0)// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 ਸਥਿਰ ਫਲੋਟ K1 = ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2));ਰੈਂਡਰ _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {// A ਅਤੇ B ਫਲੋਟ ਦੀਆਂ ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਕੋਸਾਈਨਾਂ cosA = cos (A), sinA = sin (A); ਫਲੋਟ cosB = cos (B), sinB = sin (B);ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = '; ਫਲੋਟ ਜ਼ਬਫਰ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0;// ਥੀਟਾ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈਇੱਕ ਟੋਰਸ ਦਾ ਚੱਕਰ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ <2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਥੀਟਾ ਫਲੋਟ ਕੋਸਥੀਟਾ = ਕੋਸ (ਥੀਟਾ) ਦੀਆਂ ਕੋਸਾਈਨਾਂ ਲਈ,ਸਿੰਥੇਟਾ = sin (ਥੀਟਾ);// ਫਾਈ ਇੱਕ ਟੋਰਸ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ)ਅਤੇ ਫਾਈ ਫਲੋਟ ਕੌਸਫ਼ੀ ਦੀਆਂ ਕੋਸਾਈਨਾਂ = ਕੌਸ (ਫਾਈ), ਸਿਨਫੀ = ਸਾਈਨ (ਫਾਈ);// ਚੱਕਰ ਦਾ x, y ਨਿਰਦੇਸ਼ਾਂਕ, ਘੁੰਮਣ ਤੋਂ ਪਹਿਲਾਂ (ਉੱਪਰ ਦਿੱਤੇ ਤੱਤਾਂ ਵਿੱਚੋਂ ਕਾਰਕ// ਬਾਹਰ)ਸਮੀਕਰਨਾਂ) ਫਲੋਟ ਚੱਕਰ = R2 + R1 * ਕੋਸਥੀਟਾ; ਫਲੋਟ ਚੱਕਰ = R1 * ਸਿੰਥੀਟਾ;// ਅੰਤਿਮ 3D (x, y, z) ਸਡ਼ਨ ਤੋਂ ਬਾਅਦ ਨਿਰਦੇਸ਼ਾਂਕ", ' [ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਹੇਠ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲੋਃ ਕਾਂਸਟ ਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; \\nਕੌਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; \\n\\nਕੌਂਸਟਫਲੋਟ R1 = 1; \\nਕੋਨਸਟ ਫਲੋਟ R2 = 2; \\nਕੋਨਸਟ ਫਲੋਟ K2 = 5; \\n// ਸਕਰੀਨ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ K1 ਦੀ ਗਣਨਾ ਕਰੋ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਲਗਭਗ ਕਿਨਾਰੇ ਉੱਤੇ \\n// ਹੁੰਦੀ ਹੈ।ਟੋਰਸ ਦਾ, ਜੋ ਕਿ x = R1 + R2 ਉੱਤੇ ਹੈ, z = 0. ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ ਦੇ 3/8ਵੇਂ ਹਿੱਸੇ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇ, ਜੋ ਕਿ ਤੋਂ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈਸਕਰੀਨ ਦੇ ਪਾਸੇ ਦਾ ਕੇਂਦਰ। \\n// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0) \\n// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 \\nਕੌਂਸਟ ਫਲੋਟ K1 =ਸਕਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)); \\n\\nrender _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ A ਅਤੇ B ਦੀਆਂ ਕੋਸਾਇਨਾਂ = cos (A), sinA =sin (A); \\n ਫਲੋਟ cosB = cos (B), sinB = sin (B); \\n\\n ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ ਉਚਾਈ] = \'; \\n ਫਲੋਟ zbuffer [0. ਸਕ੍ਰੀਨ ਚੌਡ਼ਾਈ,0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0; \\n\\n// ਥੀਟਾ ਇੱਕ ਟੋਰਸ ਦੇ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਚੱਕਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ <2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {\\n//ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਕੋਸਾਈਨਾਂ ਦੇ ਥੀਟਾ \\n ਫਲੋਟ ਕੌਸਥੇਟਾ = ਕੋਸ (ਥੀਟਾ), ਸਿੰਥੇਟਾ = ਸਾਈਨ (ਥੀਟਾ); \\n\\n// ਫਾਈ ਇੱਕ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ।ਟੋਰਸ \\n ਲਈ (ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਫਾਈ ਦੀ ਕੋਸਾਈਨਾਂ\\ਨ ਫਲੋਟ ਕੌਸਫੀ = ਕੋਸ (ਫਾਈ), ਸਿਨਫੀ = ਸਾਈਨ (ਫਾਈ); \\n//ਚੱਕਰ ਦਾ x, y ਨਿਰਦੇਸ਼ਾਂਕ, ਘੁੰਮਣ ਤੋਂ ਪਹਿਲਾਂ (ਉੱਪਰ ਦਿੱਤੀਆਂ ਸਮੀਕਰਨਾਂ ਵਿੱਚੋਂ ਫੈਕਟੋਰਡ \\n//) \\n ਫਲੋਟ ਚੱਕਰ = R2 + R1 * ਕੌਸਥੀਟਾ; \\n ਫਲੋਟ ਚੱਕਰ =R1 * ਸਿੰਥੇਟਾ; \\n\\n// ਫਾਈਨਲ 3D (x, y, z) ਸਡ਼ਨ ਤੋਂ ਬਾਅਦ ਤਾਲਮੇਲ ਕਰਦਾ ਹੈ, "" ਯਕੀਨਨ, ਇੱਥੇ ਸੋਧਿਆ ਹੋਇਆ ਕੋਡ ਹੈ ਜੋ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲਦਾ ਹੈਃ \\n "\'scsss\\nonstਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; \\nਕੌਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; \\n\\nਕੌਂਸਟ ਫਲੋਟ R1 = 1; \\nਕੌਂਸਟ ਫਲੋਟ R2 = 2; \\nਕੌਂਸਟ ਫਲੋਟ K2 = 5; \\n\\n// K1 ਅਧਾਰਤ ਗਣਨਾ ਕਰੋਆਨ ਸਕਰੀਨ ਸਾਈਜ਼ਃ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਟੋਰਸ ਦੇ ਕਿਨਾਰੇ \'ਤੇ ਲਗਭਗ \\n// ਹੁੰਦੀ ਹੈ, ਜੋ ਕਿ x = R1 + R2, z = 0\' ਤੇ ਹੁੰਦੀ ਹੈ।ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ, ਜੋ ਕਿ ਕੇਂਦਰ ਤੋਂ ਸਕ੍ਰੀਨ ਦੇ ਪਾਸੇ ਤੱਕ ਦਾ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈ। \\n// ਸਕ੍ਰੀਨ ਦੀ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0) \\n//ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 \\nਕੌਂਸਟ ਫਲੋਟ K1 = ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)); \\n\\nrender _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇA ਅਤੇ B ਦੀਆਂ ਕੋਸਾਇਨਾਂ ਫਲੋਟ cosA = cos (A), sinA = sin (A); \\n ਫਲੋਟ cosB = cos (B), sinB = sin (B); \\n\\n ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ _ ਵਿਡਥ, 0. ਸਕ੍ਰੀਨ _ ਹਾਈਟ] = \'\'; \\n ਫਲੋਟ ਜ਼ਬਫਰ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0; \\n\\n// ਥੀਟਾ ਇੱਕ ਟੋਰਸ ਦੇ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਚੱਕਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ ਲਈ<2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {\\n// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਥੀਟਾ ਦੀਆਂ ਕੋਸਾਈਨਾਂ \\n ਫਲੋਟ ਕੌਸਥੇਟਾ = ਕੋਸ (ਥੀਟਾ), ਸਿੰਥੇਟਾ = ਸਾਈਨ (ਥੀਟਾ); \\n\\n// ਫਾਈ ਜਾਂਦਾ ਹੈ(ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ) ਲਈ ਇੱਕ ਟੋਰਸ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ।ਕੋਸਫ਼ੀ = ਕੋਸ (ਫਾਈ), ਸਿਨਫ਼ੀ = ਸਾਈਨ (ਫਾਈ); \\n\\n/x, y ਚੱਕਰ ਦਾ ਨਿਰਦੇਸ਼ਾਂਕ, ", \'ਮੈਂ ਇਸ ਕੋਡ ਨੂੰ ਕੰਮ ਕਰਦੇ ਵੇਖਣ ਲਈ ਕਿੱਥੇ ਚਲਾ ਸਕਦਾ ਹਾਂ?\', \'ਤੁਸੀਂ ਇਸ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ।ਗਰਾਫਿਕਸ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਜਾਂ ਫਰੇਮਵਰਕ ਜਿਵੇਂ ਕਿ ਜੀ. ਐੱਲ. ਐੱਫ. ਡਬਲਿਊ., ਐੱਸ. ਡੀ. ਐੱਲ., ਜਾਂ ਐੱਸ. ਐੱਫ. ਐੱਮ. ਐੱਲ. ਵਿੱਚ ਕੋਡ। ਇਹ ਲਾਇਬ੍ਰੇਰੀਆਂ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਟੂਲ ਅਤੇ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਅਤੇ ਇੱਕ ਗਰਾਫੀਕਲ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਓ ਜੋ 3D ਗਰਾਫਿਕਸ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰ ਸਕਦੀ ਹੈ। \\n\\n ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਗੇਮ ਇੰਜਣ ਜਿਵੇਂ ਕਿ ਯੂਨਿਟੀ ਜਾਂ ਅਨਰੀਅਲ ਵਿੱਚ ਵੀ ਚਲਾ ਸਕਦੇ ਹੋ।ਇੰਜਣ। ਇਹ ਇੰਜਣ ਗੇਮਾਂ ਬਣਾਉਣ ਅਤੇ ਚਲਾਉਣ ਲਈ ਇੱਕ ਸੰਪੂਰਨ ਪਲੇਟਫਾਰਮ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ 3ਡੀ ਗਰਾਫਿਕਸ ਲਈ ਬਿਲਟ-ਇਨ ਸਮਰਥਨ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। \',\' ਕੀ ਕੋਈ ਤਰੀਕਾ ਹੈ?ਇੱਕ ਬਰਾਊਜ਼ਰ ਉੱਤੇ ਚਲਾਓ? \'] ', "ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਹੇਠ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਡੋਨਟ ਨੂੰ ਇੱਕ ਸਿੱਕੇ ਵਿੱਚ ਬਦਲੋਃ ਕਾਂਸਟ ਫਲੋਟ ਥੀਟਾ _ ਸਪੇਸਿੰਗ = 0.07; ਕਾਂਸਟ ਫਲੋਟ ਫਾਈ _ ਸਪੇਸਿੰਗ = 0.02; ਕਾਂਸਟ ਫਲੋਟR1 = 1; ਕਾਂਸਟ ਫਲੋਟ R2 = 2; ਕਾਂਸਟ ਫਲੋਟ K2 = 5;// ਸਕਰੀਨ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ K1 ਦੀ ਗਣਨਾ ਕਰੋ ਵੱਧ ਤੋਂ ਵੱਧ x-ਦੂਰੀ ਲਗਭਗ ਦੇ ਕਿਨਾਰੇ ਉੱਤੇ// ਹੁੰਦੀ ਹੈ।ਟੋਰਸ, ਜੋ ਕਿ x = R1 + R2, z = 0 ਉੱਤੇ ਹੈ. ਅਸੀਂ// ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਕਰੀਨ ਦੀ ਚੌਡ਼ਾਈ ਦੇ 3/8ਵੇਂ ਹਿੱਸੇ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇ, ਜੋ ਕਿ// ਕੇਂਦਰ ਤੋਂ ਦੂਜੇ ਪਾਸੇ ਤੱਕ ਦੇ ਰਸਤੇ ਦਾ 3/4ਵਾਂ ਹਿੱਸਾ ਹੈ।ਸਕਰੀਨ ਦੇ ਪਾਸੇ.// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * 3/8 = K1 * (R1 + R2)/(K2 + 0)// ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2)) = K1 ਸਥਿਰ ਫਲੋਟ K1 = ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ * K2 * 3/(8 * (R1 + R2));ਰੈਂਡਰ _ ਫਰੇਮ (ਫਲੋਟ A, ਫਲੋਟ B) {// A ਅਤੇ B ਫਲੋਟ ਦੀਆਂ ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਕੋਸਾਈਨਾਂ cosA = cos (A), sinA = sin (A); ਫਲੋਟ cosB = cos (B), sinB = sin (B);ਚਾਰ ਆਉਟਪੁੱਟ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = '; ਫਲੋਟ ਜ਼ਬਫਰ [0. ਸਕ੍ਰੀਨ _ ਚੌਡ਼ਾਈ, 0. ਸਕ੍ਰੀਨ _ ਉਚਾਈ] = 0;// ਥੀਟਾ ਕਰਾਸ-ਸੈਕਸ਼ਨਲ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈਇੱਕ ਟੋਰਸ ਦਾ ਚੱਕਰ (ਫਲੋਟ ਥੀਟਾ = 0; ਥੀਟਾ <2 * ਪਾਈ; ਥੀਟਾ + = ਥੀਟਾ _ ਸਪੇਸਿੰਗ) {// ਪ੍ਰੀ-ਕੰਪਿਊਟ ਸਾਈਨਾਂ ਅਤੇ ਥੀਟਾ ਫਲੋਟ ਕੋਸਥੀਟਾ = ਕੋਸ (ਥੀਟਾ) ਦੀਆਂ ਕੋਸਾਈਨਾਂ ਲਈ,ਸਿੰਥੇਟਾ = sin (ਥੀਟਾ);// ਫਾਈ ਇੱਕ ਟੋਰਸ ਦੇ ਇਨਕਲਾਬ ਦੇ ਕੇਂਦਰ ਦੇ ਦੁਆਲੇ ਜਾਂਦਾ ਹੈ (ਫਲੋਟ ਫਾਈ = 0; ਫਾਈ <2 * ਪਾਈ; ਫਾਈ + = ਫਾਈ _ ਸਪੇਸਿੰਗ)ਅਤੇ ਫਾਈ ਫਲੋਟ ਕੌਸਫ਼ੀ ਦੀਆਂ ਕੋਸਾਈਨਾਂ = ਕੌਸ (ਫਾਈ), ਸਿਨਫੀ = ਸਾਈਨ (ਫਾਈ);// ਚੱਕਰ ਦਾ x, y ਨਿਰਦੇਸ਼ਾਂਕ, ਘੁੰਮਣ ਤੋਂ ਪਹਿਲਾਂ (ਉੱਪਰ ਦਿੱਤੇ ਤੱਤਾਂ ਵਿੱਚੋਂ ਕਾਰਕ// ਬਾਹਰ)ਸਮੀਕਰਨਾਂ) ਫਲੋਟ ਚੱਕਰ = R2 + R1 * ਕੋਸਥੀਟਾ; ਫਲੋਟ ਚੱਕਰ = R1 * ਸਿੰਥੀਟਾ;// ਅੰਤਿਮ 3D (x, y, z) ਸਡ਼ਨ ਤੋਂ ਬਾਅਦ ਨਿਰਦੇਸ਼ਾਂਕ \n "]