135 lines
3.8 KiB
Python
135 lines
3.8 KiB
Python
import logging
|
|
from typing import Optional
|
|
|
|
from ..model.behavior import Behavior as BehaviorModel
|
|
from ..model.definition import Definition as DefinitionModel
|
|
from ..model.descriptor import Descriptor as DescriptorModel
|
|
from ..model.dna import DNA as DNAModel
|
|
from ..model.geometry import Geometry as GeometryModel
|
|
from ..model.geometry import Mesh
|
|
from ..reader.behavior import Behavior as BehaviorReader
|
|
from ..reader.definition import Definition as DefinitionReader
|
|
from ..reader.descriptor import Descriptor as DescriptorReader
|
|
from ..reader.geometry import Geometry as GeometryReader
|
|
from ..util.reader import Reader
|
|
from ..util.reference import set_geometry_reader
|
|
|
|
|
|
def load_dna(dna_path: str = None) -> DNAModel:
|
|
return DNA.load_dna(path=dna_path)
|
|
|
|
|
|
class DNA:
|
|
"""
|
|
A class used to represent the character config
|
|
"""
|
|
|
|
@staticmethod
|
|
def load_dna(path: str) -> DNAModel:
|
|
"""
|
|
Loads in the DNA from the given file path
|
|
|
|
@type dna: DNAModel
|
|
@param dna: The DNA data
|
|
|
|
@rtype: DNA
|
|
@returns: An object representing the DNA data
|
|
"""
|
|
|
|
logging.info(f"loading DNA {path}")
|
|
reader = DNA(path)
|
|
return reader.read()
|
|
|
|
def __init__(self, path: str) -> None:
|
|
self.stream_reader = Reader.create_stream_reader(path)
|
|
self.path = path
|
|
self.dna: Optional[DNAModel] = None
|
|
|
|
def read(self) -> DNAModel:
|
|
"""
|
|
Reads in the base DNA data as well as the meshes
|
|
|
|
@rtype: DNAModel
|
|
@returns: The DNA data
|
|
"""
|
|
|
|
self.dna = DNAModel(path=self.path)
|
|
self.read_base()
|
|
self.load_meshes()
|
|
return self.dna
|
|
|
|
def read_base(self) -> None:
|
|
"""Reads in the base DNA data without the mesh data"""
|
|
|
|
self.dna.descriptor = self.read_descriptor()
|
|
self.dna.definition = self.read_definition()
|
|
self.dna.behavior = self.read_behavior()
|
|
self.dna.geometry = GeometryModel()
|
|
|
|
def load_meshes(self) -> None:
|
|
"""Loads all the mesh data"""
|
|
|
|
for lod in range(self.dna.descriptor.lod_count):
|
|
for mesh_index in self.dna.definition.meshes.indices_for_lod[lod]:
|
|
self.dna.geometry.meshes[mesh_index] = self.load_mesh(
|
|
mesh_index=mesh_index
|
|
)
|
|
|
|
def load_mesh(self, mesh_index: int) -> Mesh:
|
|
"""
|
|
Loads geometry data for a single mesh at the given index
|
|
|
|
@type mesh_index: int
|
|
@param mesh_index: mesh index
|
|
|
|
@rtype: Mesh
|
|
@returns: mesh data
|
|
"""
|
|
|
|
return self.read_geometry_for_mesh_index(mesh_index=mesh_index)
|
|
|
|
def read_descriptor(self) -> DescriptorModel:
|
|
"""
|
|
Reads the descriptor part of the DNA
|
|
|
|
@rtype: DescriptorModel
|
|
@returns: Descriptor data from the DNA
|
|
"""
|
|
|
|
return DescriptorReader(self.stream_reader).read()
|
|
|
|
def read_definition(self) -> DefinitionModel:
|
|
"""
|
|
Reads the definition part of the DNA
|
|
|
|
@rtype: DefinitionModel
|
|
@returns: Definition data from the DNA
|
|
"""
|
|
|
|
return DefinitionReader(self.stream_reader).read()
|
|
|
|
def read_behavior(self) -> BehaviorModel:
|
|
"""
|
|
Reads the descriptor part of the DNA
|
|
|
|
@rtype: DescriptorModel
|
|
@returns: Descriptor data from the DNA
|
|
"""
|
|
|
|
return BehaviorReader(self.stream_reader).read()
|
|
|
|
def read_geometry_for_mesh_index(self, mesh_index: int) -> Mesh:
|
|
"""
|
|
Reads the geometry for a given mesh index
|
|
|
|
@type mesh_index: int
|
|
@param mesh_index: mesh index
|
|
|
|
@rtype: Mesh
|
|
@returns: Mesh data
|
|
"""
|
|
|
|
reader = GeometryReader(stream_reader=self.stream_reader, mesh_index=mesh_index)
|
|
set_geometry_reader(dna_path=self.path, geometry_reader=reader)
|
|
return reader.read()
|