Introducció

Els "Soft Bodies" o cossos tous són objectes que poden deformar-se de manera contínua quan s'apliquen forces sobre ells. A diferència dels "Rigid Bodies" (cossos rígids), els cossos tous no mantenen una forma fixa i poden canviar de forma en resposta a forces externes. Aquesta característica és essencial per simular materials com la goma, la carn, els teixits i altres substàncies flexibles en els videojocs.

Conceptes Bàsics

  1. Propietats dels Soft Bodies

  • Elasticitat: Capacitat d'un material per recuperar la seva forma original després de ser deformat.
  • Viscositat: Resistència d'un material a fluir o deformar-se.
  • Plasticitat: Capacitat d'un material per mantenir una deformació permanent després de ser deformat.

  1. Models Matemàtics

  • Mètode de Malles (Mesh-Based Methods): Utilitza una malla de punts connectats per simular la deformació.
  • Mètode de Partícules (Particle-Based Methods): Utilitza partícules individuals que interactuen entre elles per simular la deformació.

Implementació de Soft Bodies

  1. Mètode de Malles

Aquest mètode utilitza una malla de punts (nodes) connectats per arestes (edges) per formar un objecte. La deformació es calcula aplicant forces als nodes i actualitzant les posicions dels nodes en conseqüència.

Exemple de Codi

class SoftBody:
    def __init__(self, nodes, edges):
        self.nodes = nodes
        self.edges = edges

    def apply_force(self, force):
        for node in self.nodes:
            node.apply_force(force)

    def update(self, dt):
        for node in self.nodes:
            node.update(dt)
        self.resolve_constraints()

    def resolve_constraints(self):
        for edge in self.edges:
            edge.resolve()

  1. Mètode de Partícules

Aquest mètode utilitza partícules individuals que interactuen entre elles mitjançant forces com la gravetat, la fricció i la tensió superficial.

Exemple de Codi

class Particle:
    def __init__(self, position, mass):
        self.position = position
        self.mass = mass
        self.velocity = Vector(0, 0)
        self.force = Vector(0, 0)

    def apply_force(self, force):
        self.force += force

    def update(self, dt):
        acceleration = self.force / self.mass
        self.velocity += acceleration * dt
        self.position += self.velocity * dt
        self.force = Vector(0, 0)

class SoftBody:
    def __init__(self, particles):
        self.particles = particles

    def apply_force(self, force):
        for particle in self.particles:
            particle.apply_force(force)

    def update(self, dt):
        for particle in self.particles:
            particle.update(dt)

Exercici Pràctic

Objectiu

Implementar un simple simulador de cossos tous utilitzant el mètode de malles.

Passos

  1. Crear una classe Node per representar els punts de la malla.
  2. Crear una classe Edge per representar les connexions entre nodes.
  3. Implementar la classe SoftBody que utilitzi nodes i arestes per simular la deformació.

Solució

class Node:
    def __init__(self, position, mass):
        self.position = position
        self.mass = mass
        self.velocity = Vector(0, 0)
        self.force = Vector(0, 0)

    def apply_force(self, force):
        self.force += force

    def update(self, dt):
        acceleration = self.force / self.mass
        self.velocity += acceleration * dt
        self.position += self.velocity * dt
        self.force = Vector(0, 0)

class Edge:
    def __init__(self, node1, node2, rest_length):
        self.node1 = node1
        self.node2 = node2
        self.rest_length = rest_length

    def resolve(self):
        delta = self.node2.position - self.node1.position
        distance = delta.length()
        difference = (distance - self.rest_length) / distance
        correction = delta * difference * 0.5
        self.node1.position -= correction
        self.node2.position += correction

class SoftBody:
    def __init__(self, nodes, edges):
        self.nodes = nodes
        self.edges = edges

    def apply_force(self, force):
        for node in self.nodes:
            node.apply_force(force)

    def update(self, dt):
        for node in self.nodes:
            node.update(dt)
        self.resolve_constraints()

    def resolve_constraints(self):
        for edge in self.edges:
            edge.resolve()

Resum

En aquesta secció, hem après sobre els cossos tous i com es poden simular en els videojocs utilitzant mètodes de malles i partícules. Hem explorat les propietats clau dels cossos tous, com l'elasticitat, la viscositat i la plasticitat, i hem implementat exemples pràctics per il·lustrar aquests conceptes. A més, hem proporcionat un exercici pràctic per reforçar els coneixements adquirits.

© Copyright 2024. Tots els drets reservats