Applikationsmallar

Användning

Applikationsmallar är en funktion som gör det möjligt att definiera en återanvändbar konfiguration som kan väljas för att ersätta standardkonfigurationen, utan att det krävs en separat Blender-installation eller att dina personliga inställningar skrivs över.

Applikationsmallar kan väljas från startskärmen eller från undermenyn Arkiv ‣ Ny. Om det inte finns några mallar visas inte menyn på startskärmen.

Nya applikationsmallar kan installeras från Blender-meny. Om du vill behålla den aktuella applikationsmallen aktiv när du startar om Blender, spara dina inställningar.

Motivering

I vissa fall räcker det inte att skriva ett enda skript eller tillägg och förvänta sig att någon ska byta ut sina inställningar och sin startfil, installera skript och ändra sin tangentmappning.

Målet med applikationsmallar är att stödja byte till en anpassad konfiguration utan att störa dina befintliga inställningar och installation. Detta innebär att människor kan bygga sina egna applikationer ovanpå Blender som enkelt kan distribueras.

Detaljer

En applikationsmall kan definiera sin egen:

Startfil

Standardfilen som ska laddas med denna mall.

Inställningar

Endast vissa inställningar från en mall används:

• Teman.

• Tillägg.

• Tangentmappningar.

• Belysning i visningsfönstret.

Startskärm

Mallar kan tillhandahålla sin egen startbild.

Python-skript

Mallar har tillgång till samma funktioner som alla andra skript, men typiska åtgärder är t.ex:

• Modifiera och byta ut delar av användargränssnittet.

• Definiera nya menyer, knappsatser och verktyg.

• Definiera en anpassad tilläggssökväg för mallspecifika tillägg.

Mallar har också sin egen användarkonfiguration, så om du sparar en startfil medan du använder en mall kommer den inte att skriva över din standardstartfil.

Layout för katalog

Mallar kan finnas på en av två platser i katalogen scripts.

Mallens placering:

{BLENDER_USER_SCRIPTS}/startup/bl_app_templates_user

{BLENDER_SYSTEM_SCRIPTS}/startup/bl_app_templates_system

Användarkonfigurationen lagras i en underkatalog:

Utan en mall:

./config/startup.blend

./config/userpref.blend

Med en mall:

./config/{APP_TEMPLATE_ID}/startup.blend

./config/{APP_TEMPLATE_ID}/userpref.blend

Se Blenders kataloglayout för detaljer om skript- och konfigurationsplatser.

Råd

Felsökning av stigar

När du skapar en applikationsmall kan du stöta på problem där sökvägar inte hittas. För att undersöka detta kan du logga utdata från alla Blenders sökvägssökningar.

Exempel på kommandoradsargument som laddar Blender med en anpassad applikationsmall (ersätt my_app_template med namnet på din egen mall):

blender --log "bke.appdir.*" --log-level -1 --app-template my_app_template

Du kan sedan kontrollera de sökvägar där försök att komma åt my_app_template görs.

Kommandoradsåtkomst

Med hjälp av kommandoradsargument kan du ställa in en launcher som öppnar Blender med en specifik appmall:

blender --app-template my_template

Mallens innehåll

Var och en av följande filer kan användas för applikationsmallar men är valfria.

startup.blend

Fabriksstartfil som ska användas för denna mall.

userpref.blend

Fabriksinställningsfil som ska användas för denna mall. Om inställningarna utelämnas delas de med standardkonfigurationen för Blender.

(Som tidigare nämnts används detta endast för en delmängd av preferenser).

splash.png

Startskärm för att åsidosätta Blenders standardkonstverk (inte inklusive rubriktext). Observera att denna bild måste vara en 1000x500-bild.

__init__.py

Ett Python-skript som måste innehålla funktionerna register och unregister.

Observera

De medföljande blend-filerna startup.blend och userpref.blend betraktas som Fabriksinställningar och skrivs aldrig över.

Användaren kan spara sina egna startinställningar/preferenser när han använder den här mallen, vilka kommer att lagras i användarkonfigurationen, men endast om mallen innehåller en egen ”userpref.blend”-fil.

De ursprungliga mallinställningarna kan laddas med hjälp av: Load Template Factory Settings från filmenyn på ungefär samma sätt som Läs in fabriksinställningar fungerar.

Skript för mallar

Även om appmallar kan använda Python-skript har de bara tillgång till samma API:er som är tillgängliga för tillägg och andra skript.

Som nämnts ovan kan du välja att ha en __init__.py i din appmall. Detta har följande fördelar:

• Ändringar kan göras i uppstart eller inställningar utan att behöva distribuera en blend-fil.

• Ändringar kan göras dynamiskt.

  Du kan t.ex. konfigurera mallen så att den kontrollerar antalet processorer, operativsystem och minne och sedan anger värden baserat på detta.

• Du kan aktivera tillägg som är kopplade till din mall.

Vid aktivering anropas funktionen register, unregister anropas när en annan mall väljs.

Eftersom dessa bara körs en gång måste alla ändringar av standardinställningarna göras via hanteraren. Två handlers som du sannolikt kommer att använda är:

• bpy.app.handlers.load_factory_preferences_post

• bpy.app.handlers.load_factory_startup_post

Med dessa kan du definiera dina egna ”fabriksinställningar”, som användaren kan ändra, precis som Blender har sina egna standardinställningar när den först startas.

Detta är ett exempel på filen __init__.py som definierar standardvärden för en appmall som ska användas.

import bpy
from bpy.app.handlers import persistent

@persistent
def load_handler_for_preferences(_):
    print("Changing Preference Defaults!")
    from bpy import context

    prefs = context.preferences
    prefs.use_preferences_save = False

    kc = context.window_manager.keyconfigs["blender"]
    kc_prefs = kc.preferences
    if kc_prefs is not None:
        kc_prefs.select_mouse = 'RIGHT'
        kc_prefs.spacebar_action = 'SEARCH'
        kc_prefs.use_pie_click_drag = True

    view = prefs.view
    view.header_align = 'BOTTOM'


@persistent
def load_handler_for_startup(_):
    print("Changing Startup Defaults!")

    # Use smooth faces.
    for mesh in bpy.data.meshes:
        for poly in mesh.polygons:
            poly.use_smooth = True

    # Use material preview shading.
    for screen in bpy.data.screens:
        for area in screen.areas:
            for space in area.spaces:
                if space.type == 'VIEW_3D':
                    space.shading.type = 'MATERIAL'
                    space.shading.use_scene_lights = True


def register():
    print("Registering to Change Defaults")
    bpy.app.handlers.load_factory_preferences_post.append(load_handler_for_preferences)
    bpy.app.handlers.load_factory_startup_post.append(load_handler_for_startup)

def unregister():
    print("Unregistering to Change Defaults")
    bpy.app.handlers.load_factory_preferences_post.remove(load_handler_for_preferences)
    bpy.app.handlers.load_factory_startup_post.remove(load_handler_for_startup)