Spaces:

aiqtech
/

Porn-Hub

Running

App Files Files Community

aiqtech commited on Dec 10, 2024

Commit

10e0fb7

verified ·

1 Parent(s): 9b0615b

Update app.py

Browse files

Files changed (1) hide show

app.py +284 -0

app.py CHANGED Viewed

	@@ -0,0 +1,284 @@

+import gradio as gr
+import json
+import os
+from pathlib import Path
+import shutil
+def create_game_html(model_path):
+    html_template = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>3D Open World Game</title>
+        <style>
+            body {{ margin: 0; }}
+            canvas {{ display: block; }}
+            #instructions {{
+                position: absolute;
+                top: 10px;
+                left: 10px;
+                background: rgba(0,0,0,0.7);
+                color: white;
+                padding: 10px;
+                border-radius: 5px;
+                font-family: Arial, sans-serif;
+            }}
+        </style>
+        <script async src="https://unpkg.com/[email protected]/dist/es-module-shims.js"></script>
+        <script type="importmap">
+            {{
+                "imports": {{
+                    "three": "https://unpkg.com/[email protected]/build/three.module.js",
+                    "three/addons/": "https://unpkg.com/[email protected]/examples/jsm/"
+                }}
+            }}
+        </script>
+    </head>
+    <body>
+        <div id="instructions">
+            Controls:<br>
+            W - Move Forward<br>
+            S - Move Backward<br>
+            A - Move Left<br>
+            D - Move Right<br>
+            Mouse - Look Around
+        </div>
+        <script type="module">
+            import * as THREE from 'three';
+            import {{ GLTFLoader }} from 'three/addons/loaders/GLTFLoader.js';
+            import {{ PointerLockControls }} from 'three/addons/controls/PointerLockControls.js';
+            // 기본 설정
+            const scene = new THREE.Scene();
+            const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+            const renderer = new THREE.WebGLRenderer();
+            renderer.setSize(window.innerWidth, window.innerHeight);
+            renderer.shadowMap.enabled = true;
+            document.body.appendChild(renderer.domElement);
+            // 포인터 락 컨트롤
+            const controls = new PointerLockControls(camera, document.body);
+            // 키보드 입력 처리
+            const moveState = {{
+                forward: false,
+                backward: false,
+                left: false,
+                right: false
+            }};
+            document.addEventListener('keydown', (event) => {{
+                switch (event.code) {{
+                    case 'KeyW':
+                        moveState.forward = true;
+                        break;
+                    case 'KeyS':
+                        moveState.backward = true;
+                        break;
+                    case 'KeyA':
+                        moveState.left = true;
+                        break;
+                    case 'KeyD':
+                        moveState.right = true;
+                        break;
+                }}
+            }});
+            document.addEventListener('keyup', (event) => {{
+                switch (event.code) {{
+                    case 'KeyW':
+                        moveState.forward = false;
+                        break;
+                    case 'KeyS':
+                        moveState.backward = false;
+                        break;
+                    case 'KeyA':
+                        moveState.left = false;
+                        break;
+                    case 'KeyD':
+                        moveState.right = false;
+                        break;
+                }}
+            }});
+            // 클릭으로 게임 시작
+            document.addEventListener('click', () => {{
+                controls.lock();
+            }});
+            // 지형 생성
+            const terrainGeometry = new THREE.PlaneGeometry(1000, 1000, 100, 100);
+            const terrainMaterial = new THREE.MeshStandardMaterial({{
+                color: 0x3a8c3a,
+                wireframe: false
+            }});
+            const terrain = new THREE.Mesh(terrainGeometry, terrainMaterial);
+            terrain.rotation.x = -Math.PI / 2;
+            terrain.receiveShadow = true;
+            scene.add(terrain);
+            // 지형 높낮이 설정
+            const vertices = terrainGeometry.attributes.position.array;
+            for (let i = 0; i < vertices.length; i += 3) {{
+                vertices[i + 2] = Math.random() * 10;
+            }}
+            terrainGeometry.attributes.position.needsUpdate = true;
+            terrainGeometry.computeVertexNormals();
+            // 조명 설정
+            const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
+            scene.add(ambientLight);
+            const directionalLight = new THREE.DirectionalLight(0xffffff, 1);
+            directionalLight.position.set(100, 100, 100);
+            directionalLight.castShadow = true;
+            scene.add(directionalLight);
+            // 캐릭터 모델 로드
+            let character;
+            const loader = new GLTFLoader();
+            loader.load('{model_path}', (gltf) => {{
+                character = gltf.scene;
+                character.scale.set(0.5, 0.5, 0.5);
+                character.position.y = 2;
+                character.castShadow = true;
+                character.receiveShadow = true;
+                scene.add(character);
+                // 캐릭터 그림자 설정
+                character.traverse((node) => {{
+                    if (node.isMesh) {{
+                        node.castShadow = true;
+                        node.receiveShadow = true;
+                    }}
+                }});
+            }});
+            // 카메라 초기 위치 설정
+            camera.position.set(0, 5, 10);
+            // 배경 하늘 설정
+            const skyGeometry = new THREE.SphereGeometry(500, 32, 32);
+            const skyMaterial = new THREE.MeshBasicMaterial({{
+                color: 0x87ceeb,
+                side: THREE.BackSide
+            }});
+            const sky = new THREE.Mesh(skyGeometry, skyMaterial);
+            scene.add(sky);
+            // 나무와 바위 추가
+            function addEnvironmentObject(geometry, material, count, yOffset) {{
+                for (let i = 0; i < count; i++) {{
+                    const mesh = new THREE.Mesh(geometry, material);
+                    const x = (Math.random() - 0.5) * 900;
+                    const z = (Math.random() - 0.5) * 900;
+                    const y = yOffset;
+                    mesh.position.set(x, y, z);
+                    mesh.castShadow = true;
+                    mesh.receiveShadow = true;
+                    scene.add(mesh);
+                }}
+            }}
+            // 나무 생성
+            const treeGeometry = new THREE.ConeGeometry(2, 8, 8);
+            const treeMaterial = new THREE.MeshStandardMaterial({{ color: 0x0d5c0d }});
+            addEnvironmentObject(treeGeometry, treeMaterial, 100, 4);
+            // 바위 생성
+            const rockGeometry = new THREE.DodecahedronGeometry(2);
+            const rockMaterial = new THREE.MeshStandardMaterial({{ color: 0x666666 }});
+            addEnvironmentObject(rockGeometry, rockMaterial, 50, 1);
+            // 이동 속도
+            const MOVE_SPEED = 0.5;
+            // 애니메이션 루프
+            function animate() {{
+                requestAnimationFrame(animate);
+                // 키보드 입력에 따른 이동
+                const direction = new THREE.Vector3();
+                const rotation = camera.getWorldDirection(new THREE.Vector3());
+                if (moveState.forward) {{
+                    direction.add(rotation);
+                }}
+                if (moveState.backward) {{
+                    direction.sub(rotation);
+                }}
+                if (moveState.left) {{
+                    direction.cross(camera.up).negate();
+                }}
+                if (moveState.right) {{
+                    direction.cross(camera.up);
+                }}
+                direction.y = 0;
+                direction.normalize();
+                if (controls.isLocked) {{
+                    controls.moveRight(-direction.z * MOVE_SPEED);
+                    controls.moveForward(direction.x * MOVE_SPEED);
+                    // 캐릭터 위치 업데이트
+                    if (character) {{
+                        character.position.x = camera.position.x;
+                        character.position.z = camera.position.z;
+                        // 이동 방향으로 캐릭터 회전
+                        if (direction.length() > 0) {{
+                            const angle = Math.atan2(direction.x, direction.z);
+                            character.rotation.y = angle;
+                        }}
+                    }}
+                }}
+                renderer.render(scene, camera);
+            }}
+            animate();
+            // 윈도우 리사이즈 처리
+            window.addEventListener('resize', () => {{
+                camera.aspect = window.innerWidth / window.innerHeight;
+                camera.updateProjectionMatrix();
+                renderer.setSize(window.innerWidth, window.innerHeight);
+            }});
+        </script>
+    </body>
+    </html>
+    """
+    return html_template
+def process_upload(glb_file):
+    # 업로드된 파일 처리
+    upload_dir = "uploads"
+    os.makedirs(upload_dir, exist_ok=True)
+    file_path = Path(glb_file.name)
+    dest_path = Path(upload_dir) / file_path.name
+    shutil.copy(file_path, dest_path)
+    # 게임 HTML 생성
+    game_html = create_game_html(str(dest_path))
+    # HTML 파일 저장
+    game_path = Path("game.html")
+    with open(game_path, "w", encoding="utf-8") as f:
+        f.write(game_html)
+    return str(game_path)
+# Gradio 인터페이스 설정
+iface = gr.Interface(
+    fn=process_upload,
+    inputs=[
+        gr.File(label="Upload Character Model (GLB)", type="file")
+    ],
+    outputs=gr.HTML(label="3D Open World Game"),
+    title="3D Open World Game Generator",
+    description="Upload your character model (GLB) to create a 3D open world game with WASD controls!"
+)
+if __name__ == "__main__":
+    iface.launch()