[III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

05 Out 2020, 21:28

Introdução
Nem todos têm um bom computador capaz de rodar o 3DS Max sem travamentos e outros preferem o Blender pelo fato dele ser mais leve[1]. Com o DragonFF tornou-se possível exportar objetos para o jogo sem ter uma grande quantidade de programas instalados, porém problemas ainda podem acontecer. O objetivo desde tópico é anotar os mais comuns e mostrar a solução. Muitas vezes a solução para um problema é encontrada sem ser repostada na internet.

Faces do modelo "invisíveis" com o SkyGFX instalado.
Com SkyGFX:
Imagem

Sem SkyGFX:
Imagem

Motivo:
A building pipeline do GTA San Andreas não tem suporte para Vertex Alpha, mas o SkyGFX adiciona de volta. E pelo fato do Blender não exibir o canal alfa (só mexendo nos nodes para deixar o que é visível em preto, invisível em branco, etc), há grande chances que você não irá perceber se há algum erro no Vertex Alpha. E para piorar, o erro só é visível com o SkyGFX instalado.
(tópico escrito enquanto na versão 2.90.1).

É comum acontecer se estiver usando addons como o "Bake to Vertex Color" que dá bake combinando ambient occlusion, emission, sombras e cor. (use só Ambient Occlusion e use Data Transfer para combinar diferentes) https://gumroad.com/l/zdgxg Ou depois de importar, editar e exportar com o edge split marcado.

Ter cuidado redobrado.

Imagem

Solução:
Ir no modo Vertex Paint, ligar o Wireframe (Z ➡ 4), aumentar o tamanho do pincel no máximo e passar o pincel "Add Alpha" com a cor branca. Passar de frente, de lado e de cima para ter certeza que o pincel passou por todo modelo.
(O Blender tem a opção "Set Vertex Colors" mas não tem "Set Vertex Colors Alpha", então tem que fazer isso...)
Imagem

Objeto piscando, brilhando, mudando de cor ao virar a câmera ou objeto "apagado"
Imagem

(gif 1,67MB)

Motivo:
É o exato mesmo problema desse vídeo. Só que o efeito é diferente se exportar para o GTA San Andreas.
A "Subsurface Color" na aba do material e "Color" na aba de exportação de material do DragonFF devem estar com o brilho em 1.0 ao invés de 0.906

Objeto com coordenadas; posição diferentes no SA-MP Map Editor e ingame
Motivo:

SpoilerAbrir

Isso acontece não só no Blender. [1]
A questão é que no 3DS Max dá para importar/exportar .IPL, e no Blender não. (há suporte parcial)

Se você montar uma cidade ou qualquer coisa do gênero no Blender, e exportar todos os modelos em massa [2], cada objeto exportado terá as coordenadas do node iguais às coordenadas do objeto dentro do Blender. O jogo não considera essas coordenadas, mas o SA-MP Map Editor sim, lá os objetos apareceram em um lugar e no jogo, em outro. E você não conseguirá organizar os objetos.

Solução:
Sempre que você exportar no Blender as coordenadas devem estar zeradas:
*clique no objeto*
SHIFT+S ➡ (1) "Cursor to World Origin"
SHIFT+S ➡ (8) "Selection to Cursor"
ou se preferir só mudar a posição do objeto para "x: 0 y: 0 z: 0" no painel da direita.

O mesmo vale para a escala e rotação do objeto: (se estiver com tamanho diferente no Blender e dentro do jogo)
*clique no objeto*
CTRL+A ➡ "All Transforms" (aplicar tamanho e rotação à malha do objeto)

Você pode usar instancing para organizar os objetos, mas não conseguirá editá-los pela "cópia"/"fantasma" deles e com muitos objetos surgirá problemas de organização.

Resolvido nas versões mais novas do DragonFF.
Desmarcando "Preserve Positions" no "Mass Export" ou exportando individualmente o objeto a posição é ignorada.

Crash
0x00532B82 mesmo com colisão feita.
Motivo:
O DragonFF exporta as colisões com o nome da coleção no Blender.
Se você exportar vários .DFFs só mudando o tipo de "Object" para "Colission Object", a parte ".dff" do nome de cada coleção vai acabar ficando no final do nome de cada colisão, e o jogo não irá reconhecer aquela colisão como a colisão do objeto. Por algum motivo, o DragonFF também exporta as colisões com as faces invertidas (?)

Solução:
Baixar o CollEditor, renomear cada colisão, tirando o sufixo ".dff" do nome, e inverter todas as faces.

Criar uma cópia do arquivo no Blender para as colisões, sem ".dff" no nome das colisões e com as faces invertidas.
Dá para fazer de forma automática com esse script. Editando ele dá para deixar com o tipo de superfície que quiser.

Imagem

05 Out 2020, 21:32

Legal ter vertex alpha ein, então quer dizer que para fazer modelos transparentes sem o uso de material transparente.

10 Out 2020, 01:32

Junior_Djjr escreveu: ↑
05 Out 2020, 21:32
Legal ter vertex alpha ein, então quer dizer que para fazer modelos transparentes sem o uso de material transparente.

Sim... Mas sem o SkyGFX e o buildingPipe=Xbox não funciona, fazer uso exclusivo disso em mapas é ruim para usuários de ENB Series, ReShade, RenderHook e afins. É mais para os DFFs que já vêm no jogo ficarem como nos videogames e arrumar o que foi feito na pressa pela Rockstar Games.

(vídeo com chuva, estava testando cull zones)

24 Nov 2020, 23:09

Alguns scripts úteis:

É necessário trocar para o modo "text editor" e criar um arquivo novo para rodá-los.
Imagem

Resetar propriedades dos materiais de um modelo:
Para resolver o problema - Objeto piscando, brilhando, mudando de cor ao virar a câmera ou objeto "apagado" - citado acima.

Código: Selecionar tudo

import bpy

for m in bpy.data.materials:
    if m.node_tree:
        m.node_tree.nodes["Principled BSDF"].inputs['Subsurface Color'].default_value = [1, 1, 1, 1]
        m.node_tree.nodes["Principled BSDF"].inputs['Roughness'].default_value = 1
        m.node_tree.nodes["Principled BSDF"].inputs['Specular'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs['Sheen Tint'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs['Clearcoat Roughness'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs['IOR'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs[0].default_value = [1, 1, 1, 1]

Resetar as propriedades dos materiais de todos objetos do arquivo

Código: Selecionar tudo

import bpy

for obj in bpy.data.objects:
    if obj.type == 'MESH':
        bpy.context.view_layer.objects.active = obj
        for mat in bpy.data.materials:
            if mat.node_tree:
                mat.node_tree.nodes["Principled BSDF"].inputs['Subsurface Color'].default_value = [1, 1, 1, 1]
                mat.node_tree.nodes["Principled BSDF"].inputs['Roughness'].default_value = 1
                mat.node_tree.nodes["Principled BSDF"].inputs['Specular'].default_value = 0
                mat.node_tree.nodes["Principled BSDF"].inputs['Sheen Tint'].default_value = 0
                mat.node_tree.nodes["Principled BSDF"].inputs['Clearcoat Roughness'].default_value = 0
                mat.node_tree.nodes["Principled BSDF"].inputs['IOR'].default_value = 0
                mat.node_tree.nodes["Principled BSDF"].inputs[0].default_value = [1, 1, 1, 1]

Dividir modelo em partes: (para lidar com colisões invisíveis)
Não é possível descobrir a causa das colisões invisíveis sem estudar profundamente a engine do jogo e os formatos de arquivo, e ainda, tratando-se de 2020, é um problema de origem desconhecida. Porém:
‣ Em uma das guidelines antigas do MTA é dito que a mesh de colisão não pode ultrapassar 512 de altura, 512 de largura e 512 de comprimento e que a colisão não pode ultrapassar 3000 triângulos ou 65535 esferas primitivas. E que o problema ainda pode persistir, mesmo seguindo essas regras.
‣ Com várias experimentações que eu fiz eu percebi que as colisões invisíveis também acontecem quando você tem uma construção com o exterior e interior no mesmo .DFF.
E em último caso, mesmo depois de simplificar a mesh, fazendo um modelo lowpoly para a colisão, você pode repartir o modelo em partes e fazer colisões separadas para cada uma delas usando esse script:

Código: Selecionar tudo

[code]import bpy
from mathutils import Matrix, Vector
context = bpy.context
ob = context.object
size = 4 * max(ob.dimensions)
mw = ob.matrix_world

def bbox(ob):
    return (Vector(b) for b in ob.bound_box)

def bbox_center(ob):
    return sum(bbox(ob), Vector()) / 8

def bbox_axes(ob):
    bb = list(bbox(ob))
    return tuple(bb[i] for i in (0, 4, 3, 1))

o, x, y, z = bbox_axes(ob)

bpy.ops.mesh.primitive_plane_add(
        location=mw @ bbox_center(ob),
        size=size)
chopper = context.object
m = chopper.modifiers.new("Sol", type='SOLIDIFY')
m.thickness = size


chopper.select_set(False)

def chop(ob, start, end, segments):
    slices =
    planes = [(f, start.lerp(end, f / segments))
            for f in   range(1, segments)]

    for i, p in planes:
        m.thickness = -size
        bm = ob.modifiers.new("BOOL",type="BOOLEAN")
        bm.object = chopper
        bm.operation = 'DIFFERENCE'
        M = (mw @ end - mw @ start).to_track_quat('Z', 'X').to_matrix().to_4x4()
        M.translation = mw @ p

        chopper.matrix_world = M
        cp = ob.copy()
        cp.data = cp.data.copy()
        context.scene.collection.objects.link(cp)
        bpy.ops.object.modifier_apply({"object" : cp}, modifier="BOOL")
        slices.append(cp)
        m.thickness = size
        bpy.ops.object.modifier_apply(
                {"object" : ob}, modifier = 'BOOL')
    slices.append(ob)
    return slices

segments_x = 4
segments_y = 1
segments_z = 3

for ox in chop(ob, o, x, segments_x):
    for oy in chop(ox, o, y, segments_y):
        chop(oy, o, z, segments_z)

bpy.data.objects.remove(chopper)[/i]

[/code]

Se der erro, é culpa do BBCode que tira os colchetes, não tá 100% no fórum. Link original: modeling - slicing an object in 4 parts - blender stack exchange
Nota:

Código: Selecionar tudo

[i][i]segments_x = 0
segments_y = 0
segments_z = 0[/i][/i]

É a seção do script que define onde o modelo será divido.

É gambiarra? É.
Mas em um dos últimos casos, é melhor do que nada.
O melhor por agora, depois de simplificar a colisão, é dividir o modelo de maneira inteligente, fazer um para o terreno, outro para as casas, outro para o interior, outro para o telhado, ...

22 Dez 2020, 15:22

Legacy escreveu: ↑
24 Nov 2020, 23:09
Alguns scripts úteis:

É necessário trocar para o modo "text editor" e criar um arquivo novo para rodá-los.

Resetar propriedades dos materiais de um modelo:
Para resolver o problema - Objeto piscando, brilhando, mudando de cor ao virar a câmera ou objeto "apagado" - citado acima.
Código: Selecionar tudo
import bpy

for m in bpy.data.materials:
    if m.node_tree:
        m.node_tree.nodes["Principled BSDF"].inputs['Roughness'].default_value = 1
        m.node_tree.nodes["Principled BSDF"].inputs['Specular'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs['Sheen Tint'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs['Clearcoat Roughness'].default_value = 0
        m.node_tree.nodes["Principled BSDF"].inputs['IOR'].default_value = 0
Dividir modelo em partes: (para lidar com colisões invisíveis)
Não é possível descobrir a causa das colisões invisíveis sem estudar profundamente a engine do jogo e os formatos de arquivo, e ainda, tratando-se de 2020, é um problema de origem desconhecida. Porém:
‣ Em uma das guidelines antigas do MTA é dito que a mesh de colisão não pode ultrapassar 512 de altura, 512 de largura e 512 de comprimento e que a colisão não pode ultrapassar 3000 triângulos ou 65535 esferas primitivas. E que o problema ainda pode persistir, mesmo seguindo essas regras.
‣ Com várias experimentações que eu fiz eu percebi que as colisões invisíveis também acontecem quando você tem uma construção com o exterior e interior no mesmo .DFF.
E em último caso, mesmo depois de simplificar a mesh, fazendo um modelo lowpoly para a colisão, você pode repartir o modelo em partes e fazer colisões separadas para cada uma delas usando esse script:
Código: Selecionar tudo
import bpy
from mathutils import Matrix, Vector

context = bpy.context
ob = context.object
size = 4 * max(ob.dimensions)
mw = ob.matrix_world

def bbox(ob):
    return (Vector(b) for b in ob.bound_box)

def bbox_center(ob):
    return sum(bbox(ob), Vector()) / 8

def bbox_axes(ob):
    bb = list(bbox(ob))
    return tuple(bb[i] for i in (0, 4, 3, 1))

o, x, y, z = bbox_axes(ob)

bpy.ops.mesh.primitive_plane_add(
        location=mw @ bbox_center(ob),
        size=size)
chopper = context.object
m = chopper.modifiers.new("Sol", type='SOLIDIFY')
m.thickness = size


chopper.select_set(False)

def chop(ob, start, end, segments):
    slices =
    planes = [(f, start.lerp(end, f / segments))
            for f in   range(1, segments)]

    for i, p in planes:
        m.thickness = -size
        bm = ob.modifiers.new("BOOL",type="BOOLEAN")
        bm.object = chopper
        bm.operation = 'DIFFERENCE'
        M = (mw @ end - mw @ start).to_track_quat('Z', 'X').to_matrix().to_4x4()
        M.translation = mw @ p

        chopper.matrix_world = M
        cp = ob.copy()
        cp.data = cp.data.copy()
        context.scene.collection.objects.link(cp)
        bpy.ops.object.modifier_apply({"object" : cp}, modifier="BOOL")
        slices.append(cp)
        m.thickness = size
        bpy.ops.object.modifier_apply(
                {"object" : ob}, modifier = 'BOOL')
    slices.append(ob)
    return slices

segments_x = 0
segments_y = 0
segments_z = 0

for ox in chop(ob, o, x, segments_x):
    for oy in chop(ox, o, y, segments_y):
        chop(oy, o, z, segments_z)

bpy.data.objects.remove(chopper)[/i]
Nota:
Código: Selecionar tudo
segments_x = 0
segments_y = 0
segments_z = 0
É a seção do script que define onde o modelo será divido.

É gambiarra? É.
Mas em um dos últimos casos, é melhor do que nada.
O melhor por agora, depois de simplificar a colisão, é dividir o modelo de maneira inteligente, fazer um para o terreno, outro para as casas, outro para o interior, outro para o telhado, ...

Sobre problemas com col, descobri como arrumar as colisão apenas olhando as col original do jogo, os modelos do jogo tem um serio problema de facedupla invertida, que pode ser soldada com as faces adjacente, isso gera um problema satanico de col. Outro problema é sobre respeitar o limite de cada divisão de modelo, voce nao pode fazer isso aqui:
Imagem

Outra coisa importante que tambem evita problemas e deixa o modelo mais leve. Ruas ou qualquer modelo com uma pequena elevação nao é necessário estar conectado, deve-se retirar a face que conecta a parte de cima com a de baixo.

06 Jan 2021, 20:18

LOD aparecendo por cima do objeto.
Objeto sem colisão.
LOD com sobra.
[RESOLVIDO] preciso de ajuda com LODs para objetos personalizados - Fórum MixMods

Céu desaparecendo ao sair de um interior (flags erradas no ENEX)
f6-mapas-objetos/t6004-sa-galaxy-of-ter ... ior#p38182

13 Ago 2021, 11:58

Addon que achei interessante:
Download: mrven/Blender-Asset-Creation-Toolset
Links do autor: GitHub / GumRoad
Serve para dar merge em bone e transferir os bone weights, alternativa para isso, só que no 2.90 adiante. Estou testando ainda para ver como que funciona. Nunca tive experiência com conversão de personagens, se aprender já era.
Imagem

EDIT: Não aprendi a usar. Tenho que pegar experiência na modelagem de personagens com Unity, VRChat, Neos VR, .. qualquer jogo que seja fácil de colocar modelos, não dê crash e dê para experienciar os erros e ir arrumando antes de tentar fazer algo para GTA que é mais difícil.

Script útil do ajanhallinta para exportação de mapas (talvez faça tutorial quando tiver tempo, usei nesse teste):
Download: ajanhallinta/GTARW-BlenderMapExport (Archive.org) (o pessoal que faz projetos pequenos como esse tem mania de apagar)
Links do autor: GTAInside / RaceDepartment / YouTube

Script para definir o vertex color dos objetos selecionados: (nas linhas 19 e 21 você escolhe a cor de dia e noite)

Código: Selecionar tudo

from bpy import context

def color_from_active():
    active = context.active_object
    selection = context.selected_objects
    objs = [o for o in selection if not o is active and o.type == 'MESH']
    
    if not objs or not 'OBJECT' in context.mode:
        print("No selection")
        return

    objs.append(active)  
    if objs:
        for o in objs:
            if not o.data.vertex_colors:
                v_col = o.data.vertex_colors.new()
                v_col = o.data.vertex_colors.new()
            for data in o.data.vertex_colors[0].data:
                data.color = [0.4,0.4,0.4,1]
            for data in o.data.vertex_colors[1].data:
                data.color = [0.05,0.05,0.05,1]
        
if __name__ == "__main__":
    color_from_active()

Script de cima modificado para pegar objetos no Blender e colocar em coleções com o nome de cada um + ".dff": (para exportar com o DFF)

Código: Selecionar tudo

from bpy import context, data

def collection_dff():
    active = context.active_object
    selection = context.selected_objects
    objs = [o for o in selection if not o is active and o.type == 'MESH']

    if not objs or not 'OBJECT' in context.mode:
        print("No selection")
        return

    objs.append(active)
    if objs:
        for o in objs:
            collection = data.collections.new(name = o.name + ".dff")
            context.scene.collection.children.link(collection)
            if o.users_collection:
                collection = o.users_collection[0]
                collection.objects.unlink(o)
            collection = data.collections[o.name + ".dff"]
            collection.objects.link(o)
if __name__ == "__main__":
    collection_dff()

Script para copiar a linha IPL do objeto selecionado: (feito em cima do script original do ajanhallinta)

Código: Selecionar tudo

import os
import bpy

#IPL settings
lod = -1
interior = 0
drawDistance = 300
id = 15076
scale=1

def get_ipl_line():
    obj = bpy.context.active_object
    
    name = obj.name.split('.')[0] # Remove duplicated names
    posX = str(obj.location.x + obj.delta_location.x * scale)
    posY = str(obj.location.y + obj.delta_location.y * scale)
    posZ = str(obj.location.z + obj.delta_location.z * scale)
    rotX = 0.0 #obj.rotation_quaternion[0]
    rotY = 0.0 #obj.rotation_quaternion[1]
    rotZ = -1.0 #obj.rotation_quaternion[2]
                  
    if "invertZ" in obj: rotZ = -rotZ # (Optional) Rotation Z Invert                
                   
    iplString = "%s, %s, %s, %s, %s, %s, 0.0, %s, %s, %s, %s" % (id, name, interior, posX, posY, posZ, rotX, rotY, rotZ, lod)

    bpy.context.window_manager.clipboard = iplString
    
if __name__ == "__main__":
    get_ipl_line()

Script para gerar zona cull de chuva a partir de um cubo: (feito em cima do script original do ajanhallinta e uma parte do stackoverflow)

Código: Selecionar tudo

import os
import bpy

def get_cullzone():
    obj = bpy.context.active_object
     
    flag = 8
    
    name = obj.name.split('.')[0] # Remove duplicated names
    posX = float(obj.location.x + obj.delta_location.x)
    posY = float(obj.location.y + obj.delta_location.y)
    posZ = float(obj.location.z + obj.delta_location.z)
    length = float(obj.dimensions.y / 2)
    width = float(obj.dimensions.x / 2)
    lowest_pt = min([(obj.matrix_world @ v.co).z for v in obj.data.vertices])
    highest_pt = max([(obj.matrix_world @ v.co).z for v in obj.data.vertices])
                   
    cullStrng = "%.2f, %.2f, %.2f, 0, %.2f, %.2f, %.2f, 0, %.2f, %s, 0" % (posX, posY, posZ, length, lowest_pt, width, highest_pt, flag)

    bpy.context.window_manager.clipboard = cullStrng
    
if __name__ == "__main__":
    get_cullzone()

A meta é uma hora pegar tudo isso e criar um addon.

19 Fev 2022, 17:19

Atualização do DragonFF:
• Enable Lightning -> Flag que faz a opção de gamma do jogo afetar o vertex color, aumentar/diminuir o brilho do jogo afetará o brilho do objeto. (Como já acontecia antes.)(sim, sei que gamma != brilho != contraste; é sobre os valores guardados no objeto, só que eu não entendo tanto, nem quero usar termos confusos)
Imagem

Com a opção desligada:Abrir

No quê deixar desligado? Pickups, ícones de interior, marcas de chão, ..

• Enable Module Material Color:
É o ambient color que você escolheu, desligando é possível remediar o problema do SketchUp em que a cor do material é obtida a partir da textura.
Imagem

Mais um adendo sobre as colisões invisíveis:
Um outro problema são as T vertices. O SketchUp preenche elas com um triângulo no meio.
Imagem

(Créditos: Davy Lopes; indicação do problema Raphael)
Modele no SketchUp como se estivesse modelando em qualquer outro programa, 3DS Max, Blender, etc. e você não terá o problema.
Não crie faces "livres". Faça tudo em quads ou triângulos. Ou o programa converterá por você e fará um trabalho malfeito.
Imagem

(Créditos: Junior_Djjr)

‣ Tópico do Junior_Djjr sobre o assunto:
f34-tutoriais/t6556-gta-como-corrigir-p ... col-do-ske

Porque continuo postando isso no fórum, ao invés de só deixar a informação no Discord da MixMods?
https://knockout.chat/thread/33251/1
Daqui 7~8 anos o Discord irá acabar, talvez 10~15, ou talvez o servidor da MixMods no Discord seja fechado daqui há alguns anos, ou ambos. Nada tuda para sempre.
A questão é que fóruns retém informação, o Discord não. Tópicos de 2007-2008 no GTAForums já me ajudaram muito a fazer mods. Estou só retribuindo.
Gostaria de ver mais pessoas utilizando o fórum.

17 Abr 2022, 00:20

Já faz um bom tempo que comecei ter vontade em criar objetos e/ou mapas para GTA SA. Mas, sempre achei uma bosta fazer isso usando o Map Editor. Existia o addon GTA Tools for Blender para o Blender 2.79 na época, mas não era aquelas coisas... Quando foi lançado a versão 2.80 e assim por diante do Blender, comecei aprender fazer addons, pois vi um potencial gigantesco nisso.

Então comecei fazer um script simples que exportava as propriedades do objeto selecionado da cena para um arquivo de texto. Mas, algumas informações eu tinha que passar manualmente, pois, eu não tinha um conhecimento amplo sobre a documentação. Com isso, comecei vasculhar a internet de cabo a rabo. Em meio a isso, encontrei o DragonFF, mas ainda sem a capacidade de exportar o mapa para o arquivo ipl, o que eu tanto precisava!!!
Em meio as discussões no fórum, acabei encontrando uns scripts do ajanhallinta como aqui já mencionado.

Legacy escreveu: ↑
13 Ago 2021, 11:58
Script útil do ajanhallinta para exportação de mapas

Com os scripts em mente, comecei a juntar eles com os meus — que até então estava funcionando bem. Entretanto, como era simples, eu sempre tinha que ficar colocando a ID de cada objeto. Mas, comecei enfrentar vários problemas e muita frustração quando as coisas começaram a ficar mais complexas. Em 2020 ingressei na universidade, e como foram meses de pandemia e muita falta de paciência, acabei botando fim nisso quando as aulas retornaram em 2021. Pois, estou sem tempo!!!

Depois de praticamente um ano me veio isso na cabeça de novo. Então decidi recomeçar de onde parei.

Criei este tópico para resolver um problema que eu ainda estou enfrentando — apesar de eu ter colocado como resolvido

. Até que encontrei este tópico e ca estou escrevendo.

Então, decidi juntar tudo o que eu tenho e postar isso como uma comemoração de páscoa.

Menu para pegar os objetos com a propriedade 'ID':

E para definir a ID de cada objeto, eu criei um script que lê um arquivo ide ou txt mesmo — desde que esteja escrito certo, o qual sai verificando o nome dos objetos selecionados com a lista. Quando encontra, simplesmente cria a propriedade contendo o valor da ID:

Como eu estava muito satisfeito com o resultado, decidi criar um script para converter os materiais dos objetos. Pois, sempre que você importa um objeto com o DragonFF, ele não cria material transparente. Tornando isso um processo manual. Imagina fazer isso com um mapa inteiro...

O ruim do DragonFF é que ele cria vários materiais duplicados, futuramente vou criar um script para resolver isso. Mas, por enquanto apenas converter já quebra o galho:

Link do repositório que criei contendo todos os scripts

É só importar e executar os scripts 'GTA_SA_Tools.py' e 'converterObjs.py'. Creio eu que se tudo der certo vai aparecer um menu na parte lateral direita da viewport 3D.

17 Abr 2022, 16:22

Esqueci de mencionar... Mas, para que o script "converterMat.py" funcione, você precisa instalar a biblioteca Pillow.

Para fazer isso, será necessário executar o comando abaixo:

Código: Selecionar tudo

pip install Pillow

Porem, o Blender usa seu próprio diretório para o Python. Assim sendo, será necessário trazer os arquivos para a pasta "Blender 3.0\3.0\python\lib\site-packages".

17 Abr 2022, 16:52

O Blender recentemente introduziu o Asset Browser. Mas, como ainda está em desenvolvimento, às vezes o catalogo não aparece quando você abre em outro projeto. Para contornar este problema, percebi que posso criar tags utilizadas para busca. Muito útil não só para separar os objetos de acordo com sua categoria, mas, também para encontrar objetos específicos mais rapidamente.

O problema que encontrei foi a necessidade de adicionar, remover e renomear as tags de vários objetos ao mesmo tempo. Pois, só era possível fazer isso um a um.

Então criei este script para gerenciar as tags:

Código: Selecionar tudo

# by Pommersch

import bpy

from bpy.types import Panel, Operator, PropertyGroup
from bpy.props import StringProperty, PointerProperty

class MyProperties(PropertyGroup):
    # Propriedades
    tagName: StringProperty(name = "Nome")
    renameTag: StringProperty(name = "Renomear")

class PainelPrincipal(Panel):
    bl_label = "Gerenciar Tags"
    bl_idname = "ManagerTags_Panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'GTA SA Tools'

    def draw(self, context):
        layout = self.layout
        scene = context.scene
        mytool = scene.my_tool

        layout.prop(mytool, "tagName")
        layout.operator("add_tags.button_operator")
        layout.operator("remove_tags.button_operator")

        row = layout.row()
        layout.prop(mytool, "renameTag")
        layout.operator("rename_tags.button_operator")

# Adicionar tags
class AddTags(Operator):
    bl_label = "Adicionar"
    bl_idname = "add_tags.button_operator"

    def execute(self, context):
        scene = context.scene
        mytool = scene.my_tool
        tagName = mytool.tagName

        # Objetos selecionados
        objs = bpy.context.selected_objects

        for n in objs:
            asset = n.asset_data
            newTag = asset.tags.new(tagName)

        return {'FINISHED'}

# Remover tags
class RemoveTags(Operator):
    bl_label = "Remover"
    bl_idname = "remove_tags.button_operator"

    def execute(self, context):
        scene = context.scene
        mytool = scene.my_tool
        tagName = mytool.tagName

        # Objetos selecionados
        objs = bpy.context.selected_objects

        for n in objs:
            asset = n.asset_data
            asset.tags.remove(asset.tags[tagName])

        return {'FINISHED'}

class RenameTags(Operator):
    bl_label = "Renomear"
    bl_idname = "rename_tags.button_operator"

    def execute(self, context):
        scene = context.scene
        mytool = scene.my_tool
        tagName = mytool.tagName
        renameTag = mytool.renameTag

        # Objetos selecionados
        objs = bpy.context.selected_objects

        for n in objs:
            asset = n.asset_data
            asset.tags[tagName].name = renameTag

        return {'FINISHED'}

classes = [MyProperties, PainelPrincipal, AddTags, RemoveTags, RenameTags]

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

    bpy.types.Scene.my_tool = PointerProperty(type = MyProperties)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)

    del bpy.types.Scene.my_tool

if __name__ == "__main__":
    register()

18 Abr 2022, 21:39

Enfim, consegui resolver os problemas. Acredito que agora está funcionando como eu desejava.

Link do repositório github

02 Mar 2024, 15:42

Script atualizado:

Código: Selecionar tudo

import bpy
import os

from bpy_extras.io_utils import ExportHelper
from bpy.types import Panel, Operator, PropertyGroup
from bpy.props import StringProperty, PointerProperty, IntProperty, BoolProperty

# Propriedades do script
class IPL_Propriedades(PropertyGroup):

    interior: IntProperty(
        name = "Interior",
        min = 0,
        default = 0
    )

    lod: IntProperty(
        name = "LOD",
        min = -1,
        default = -1
    )

    modelName: BoolProperty(
        name = "Usar nome ficticio",
        description = "Usar nome ficticio ao invés do objeto",
        default = False
    )

    modelDummy: StringProperty(
        name = "Nome",
        default = "dummy"
    )

# Painel Principal
class IPL_PT_PainelPrincipal(Panel):
    bl_label = "Exportar IPL"
    bl_idname = "IPL_PT_Panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = 'UI'
    bl_category = "GTA SA Tools"

    def draw(self, context):
        layout = self.layout
        ipltool = context.scene.ipltool

        box = layout.box()
        box.prop(ipltool, "modelName")
        if ipltool.modelName:
            box.prop(ipltool, "modelDummy")

        layout.prop(ipltool, "interior")
        layout.prop(ipltool, "lod")

        layout.operator("salvar_ipl.open_filebrowser", icon="CURRENT_FILE")

# Abrir o File Browser para salvar o arquivo
class SAVE_OP_IPLFile(Operator, ExportHelper):
    bl_label = "Save"
    bl_idname = "salvar_ipl.open_filebrowser"

    # Alternar selecao dos objetos
    selecionar_objetos: BoolProperty(
        name = "Objetos selecionados",
        description = "Serao exportados apenas os objetos selecionados",
        default = False
    )

    # Organizar o arquivo
    organizar_arquivo: BoolProperty(
        name = "Arquivo organizado",
        description = "Organizar o arquivo em colunas para facilitar sua leitura",
        default = True
    )

    # Criar arquivo de carregamento
    carregar_arquivo: BoolProperty(
        name = "Criar Loader",
        description = "Criar arquivo para carregar o IPL durante a execucao do GTA",
        default = False
    )

    # Arredondar valores
    casas_decimais: IntProperty(
        name = "",
        description = "Numero de casas decimais para os valores de localizacao e rotacao do objeto",
        min = 0,
        max = 10,
        default = 5
    )

    # Mostrar arquivos com determinada extensao
    filter_glob: StringProperty(
        default = '*.ipl;*.txt',
        options = {'HIDDEN'}
    )

    # Extensao do arquivo
    filename_ext = ".ipl"

    def draw(self, context):
        layout = self.layout

        # Toggle para organizar o arquivo
        row = layout.row()
        row.prop(self, "organizar_arquivo")

        # Toggle dos objetos selecionados
        row = layout.row()
        row.prop(self, "selecionar_objetos")

        # Arquivo de carregamento
        row = layout.row()
        row.prop(self, "carregar_arquivo")

        # Numero de casas decimais
        grid = layout.grid_flow(columns=2, align=True)
        grid.label(text = "Casas decimais:")
        grid.prop(self, "casas_decimais")

    def execute(self, context):
        ipltool = context.scene.ipltool

        # Caminho e extensao do arquivo
        filename, extension = os.path.splitext(self.filepath)

        # Apenas objetos selecionados ou fazer busca completa
        select_objects = bpy.context.selected_objects if self.selecionar_objetos else bpy.data.objects

        # Verificar se objetos foram selecionados
        if select_objects ==  and self.selecionar_objetos:
            self.report({'ERROR'}, "Selecione ao menos um objeto!")
            return {'FINISHED'}

        # Dicionario do arquivo(estrutura do IPL)
        estrutura = {'id': , 'nome': , 'interior': , 'posx': , 'posy': , 'posz': ,  'rotx': , 'roty': , 'rotz': , 'rotw': , 'lod': }

        size = 0

        # Adicionar as propriedades do objeto na estrutura
        for obj in select_objects:
            if "INST" in obj:
                # ID do objeto
                estrutura['id'].append(obj['INST'])

                # Nome do objeto
                nome = ipltool.modelDummy if ipltool.modelName else obj.name.split('.')[0]
                estrutura['nome'].append(nome)

                # Adicionar as propriedades interior
                estrutura['interior'].append(ipltool.interior)

                # Rotacao em quaternion
                matrix = obj.matrix_world.to_quaternion()

                # Posicao global do objeto
                estrutura['posx'].append(f"%.{self.casas_decimais}f" % obj.location.x)
                estrutura['posy'].append(f"%.{self.casas_decimais}f" % obj.location.y)
                estrutura['posz'].append(f"%.{self.casas_decimais}f" % obj.location.z)

                # Rotacao global do objeto
                estrutura['rotx'].append(f"%.{self.casas_decimais}f" %  matrix.x)
                estrutura['roty'].append(f"%.{self.casas_decimais}f" %  matrix.y)
                estrutura['rotz'].append(f"%.{self.casas_decimais}f" %  matrix.z)
                estrutura['rotw'].append(f"%.{self.casas_decimais}f" % -matrix.w)

                # LOD do objeto
                estrutura['lod'].append(ipltool.lod)

                size += 1

        if size == 0:
            self.report({'ERROR'}, 'Sua cena nao possui objetos com a propriedade "INST"!')
            return {'FINISHED'}

        # Criar o arquvio IPL
        def criar_arquivo():
            with open(self.filepath, "w") as file:
                file.write("inst\n")

                largura_coluna =
                for coluna in estrutura: largura_coluna.append(max(len(str(item)) for item in estrutura[coluna]))

                for i in range(size):
                    for index, coluna in enumerate(estrutura):
                        valor = str(estrutura[coluna][i])

                        if self.organizar_arquivo:
                            formatacao = f"{{0:<{largura_coluna[index]}}}" if index <= 1 else f"{{0:>{largura_coluna[index]}}}"
                            item = formatacao.format(valor) + ', '
                            if coluna == "LOD": item = item[:-2]
                        else:
                            item = valor + ','
                            if coluna == "LOD": item = item[:-1]

                        file.write(item)
                    file.write("\n")
                file.write("end")
                file.close()

        # Criar arquivo para carregar o IPL
        def criar_loader():
            with open(filename + "_Load.txt", "w") as file:
                file.write(f"IPL data\\maps\\{os.path.basename(self.filepath)}")
                file.close()

        try:
            criar_arquivo()
            if self.carregar_arquivo: criar_loader()

            self.report({'INFO'}, 'Arquivo salvo com sucesso!')
        except Exception as e:
            print(e)
            self.report({'ERROR'}, 'Nao foi possivel salvar o arquivo!')

        return {'FINISHED'}

# Lista das classes
classes = (
    IPL_Propriedades,
    IPL_PT_PainelPrincipal,
    SAVE_OP_IPLFile
)

# Registrar as classes
def register():
    for cls in classes:
        bpy.utils.register_class(cls)

    bpy.types.Scene.ipltool = PointerProperty(type = IPL_Propriedades)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)

    del bpy.types.Scene.ipltool

if __name__ == "__main__":
    register()[/i]

Forum.MixMods

[III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

[III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

Re: [SA/III/Vice] Problemas de exportação de objetos pelo Blender e solução

Re: [SA/III/Vice] Problemas de exportação de objetos pelo Blender e solução

Re: [SA/III/Vice] Problemas de exportação de objetos pelo Blender e solução

Re: [SA/III/Vice] Problemas de exportação de objetos pelo Blender e solução

Re: [SA/III/Vice] Problemas de exportação de objetos pelo Blender e solução

Re: [SA/III/Vice] Problemas de exportação de objetos pelo Blender e solução

Re: [III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas

Re: [III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

Re: [III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

Re: [III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

Re: [III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)

Re: [III|VC|SA] Problemas de exportação de objetos pelo Blender, soluções e ferramentas (compilado de informações)