GridTalk.de - Externe Tools

OSSL2Gif

Thu, 12 Feb 2026 12:46:34 +0100

OSSL2Gif Version 1.0.2 – Einfache GIF-zu-Textur-Umwandlung

Mit OSSL2Gif kannst du animierte GIFs einfach in Texturen für Second Life/OpenSim umwandeln – ganz ohne Programmierkenntnisse!
Das ist ähnlich wie sl2gif hat aber nichts damit zu tun.

logo003.png (Größe: 1,55 MB / Downloads: 49)

Bedienung:
GIF laden: Klicke auf „GIF laden“ und wähle eine animierte GIF-Datei aus.
Vorschau: Das GIF und die spätere Textur werden angezeigt.
Effekte: Du kannst Graustufen, Schärfe, Weichzeichnen und Transparenz einstellen.
Bildgröße: Passe die Zielgröße der Textur an.
Randlos: Entfernt überflüssige transparente Ränder.
Play/Pause: Animation abspielen oder anhalten.
Bild hinzufügen: Einzelne GIF-Frames zur Textur hinzufügen.
Sprache: Wähle die Sprache im Dropdown-Menü.
Speichern: Speichere das GIF oder die Textur als Datei.
LSL exportieren: Erzeuge ein LSL-Skript für Second Life/OpenSim.

Demo.png (Größe: 936,76 KB / Downloads: 46)

Download Github

PBR Material Maker

Sat, 31 Jan 2026 15:25:05 +0100

PBR Material Maker 3.8.602
Allgemeines
PBR Material Maker ist ein erweitertes Tool zum Packen und Erstellen von GLTF-Dateien für PBR-Materialien. Es unterstützt das Laden, Bearbeiten und Exportieren von Texturen (Base Color, Occlusion, Roughness, Metallic, Normal, Emission, Alpha) und bietet zahlreiche Automatisierungen für die Materialerstellung und den Export.

PBR-Material-Maker1.png (Größe: 2,15 MB / Downloads: 45)

Version: 3.8.602.0
Plattform: Windows 7 und neuer (.NET 10)
Ziel: OpenSim, SecondLife, GLTF 2.0-kompatible Plattformen

Hauptfunktionen
Drag & Drop: Texturen einfach in die jeweiligen Slots ziehen.
Material-Presets: Auswahl und Verwaltung von Materialvorlagen.
Parametersteuerung: Alle relevanten Materialparameter (Stärke, Schwellenwerte, Tönung, etc.) sind direkt einstellbar.
Checkboxen für Texturtypen: Jede Map kann gezielt aktiviert/deaktiviert werden. Nur aktivierte Maps werden in die GLTF-Datei übernommen.
Bildgrößenanpassung (Resize): Alle Texturen können automatisch auf die gewünschte Auflösung skaliert werden.
Automatische Map-Generierung: Fehlende Maps (Normal, Roughness, Metallic, Occlusion, Alpha, ORM) können per Batch automatisch erzeugt werden.

Batch-Funktionen:
Batch: Generiere Fehlende Maps – Automatische Erzeugung aller fehlenden Maps im Verzeichnis.
Batch: Batch Speichern – Exportiert alle Materialien im Verzeichnis als GLTF inklusive Texturen.
Zentraler GLTF-Export: Die Funktion gltf_exporter steuert den Export und die Texturzuordnung für alle relevanten Speicherpunkte.
Fortschrittsbalken: Zeigt den Status bei längeren Batch-Operationen an.
Kompatibilität: Exportierte GLTF-Dateien sind direkt für OpenSim und SecondLife verwendbar.

UI-Komponenten
Materialauswahl & Parameter
Materialname: Eingabefeld für den Namen des Materials.
Material-Preset: Dropdown zur Auswahl vordefinierter Materialtypen.
Texturauflösung: Dropdown zur Auswahl der Zielauflösung für alle Maps.

Textur-Slots (Drag & Drop)
Base Color (Albedo)
Alpha-Map
Occlusion-Map
Roughness-Map
Metallic-Map
Normal-Map
Emission-Map
ORM-Map (Occlusion-Roughness-Metallic kombiniert)
Checkboxen für Map-Typen
Normal, ORM, Emission, Metallic, Roughness, Occlusion, Alpha
Nur aktivierte Maps werden exportiert.

Batch-Funktionen
Batch: Generiere Fehlende Maps
Automatische Erzeugung aller fehlenden Maps im aktuellen Verzeichnis. Fortschrittsbalken wird angezeigt.
Batch: Batch Speichern
Exportiert alle Materialien im Verzeichnis als GLTF inklusive Texturen. Fortschrittsbalken wird angezeigt.

Fortschrittsbalken
Zeigt den Status bei längeren Operationen (Batch-Generierung, Batch-Speichern).

Bedienung & Workflow
Texturen per Drag & Drop in die Slots ziehen.
Materialparameter und Checkboxen nach Bedarf einstellen.
Optional: Fehlende Maps automatisch generieren (Batch: Generiere Fehlende Maps).
Material exportieren (Speichern oder Batch Speichern).
GLTF-Dateien können direkt in OpenSim/SecondLife hochgeladen werden.

Hinweise & Tipps
Nur aktivierte Checkboxen werden exportiert: Über die Checkboxen kann gezielt gesteuert werden, welche Maps in die GLTF-Datei übernommen werden.
Automatische Map-Generierung: Fehlende Maps werden nach Standardparametern erzeugt, können aber nachträglich angepasst werden.
Batch-Funktionen: Ideal für die Verarbeitung ganzer Verzeichnisse mit vielen Materialien.
Fortschrittsbalken: Gibt visuelles Feedback bei längeren Prozessen.

Systemvoraussetzungen
Windows 7 oder neuer
.NET 10 Desktop Runtime
Keine Installation erforderlich, einfach ausführbar

Installation
Release herunterladen und entpacken.
Die Datei PBR Material Maker.exe ausführen.

Github Repository: https://github.com/ManfredAabye/PBR-Material-Maker

Nachtrag:
Wichtig sind 2048 Texturen für das Terrain denn das sind ja nur wenige und es wertet die ganze Region auf.
Bei Tile Texturen die aneinander gekachelt werden, kann die Größe auch unter 512 fallen da sieht man das nicht wirklich.
Tip: Testen Testen Testen

Onigiri

Sat, 03 Jan 2026 22:20:54 +0100

Ich habe mich gerade über Onigiri hergemacht, um es an Blender 5.0.1 anzupassen.
Github: https://github.com/ManfredAabye/Onigiri

Onigiri 4

Rigging-Add-on für Blender 5.0.*, basierend auf Onigiri.

Lade die .zip-Datei aus dem Bereich „Releases“ herunter, um sie als Blender-Add-on zu installieren.

Die .zip-Datei wird aus dem Code des GitHub-Repositorys erstellt und enthält nur das Onigiri-Verzeichnis.

Blender 5.0 Kompatibilität
Dieses Add-on wurde für Blender 5.0 aktualisiert:

Alle PropertyGroup- und Operator-Eigenschaftsdeklarationen wurden in das neue Zuweisung-mit-Typ-Format konvertiert.
Die Codebasis ist nun formal mit Blender 5.0 kompatibel.
Die Collada-Exportfunktion wurde entfernt/ersetzt; glTF wird nun empfohlen.

Hinweis: Für ältere Blender-Versionen (<5.0) bitte weiterhin die vorherige Add-on-Version verwenden.

Onigiri Dokumentation
Überblick
Onigiri ist ein Rigging- und Konvertierungs-Add-on für Blender, das speziell für die Arbeit mit Avataren und Animationen für OpenSim und Second Life entwickelt wurde. Es unterstützt das Mapping, die Anpassung und den Export von Rigs und Meshes, insbesondere für glTF-Workflows.

Installation

Lade das Onigiri-Add-on als ZIP-Datei herunter.
Öffne Blender und gehe zu Bearbeiten > Einstellungen > Add-ons > Installieren.
Wähle die ZIP-Datei aus und installiere das Add-on.
Aktiviere das Add-on in der Add-on-Liste.

Hauptfunktionen
1. Charakter-Konverter

Konvertiert Avatare und Rigs zu OpenSim-/Second-Life-kompatiblen Skeletten.
Unterstützt Mixamo, DAZ, Avastar und andere gängige Rigs.
Automatisches und manuelles Bone-Mapping.

2. Mapper

Detailliertes Mapping-Werkzeug für Bones zwischen Quell- und Ziel-Rigs.
Unterstützt Reskinning, Bone-Umbenennung und Hierarchieanpassung.
Visualisierung des Bone-Mappings in der 3D-Ansicht.

3. Sliders & Shape-Werkzeuge

Passe Körperformen und Proportionen mit Schiebereglern an.
Speichere und lade Shape-Voreinstellungen.

4. Export

Exportiere Modelle und Rigs als glTF 2.0 für OpenSim/Second Life.
Unterstützung für Animationen und Materialien.

Typische Workflows
Mixamo-Avatar für OpenSim/SL vorbereiten

Importiere das Mixamo-Modell (FBX).
Öffne das Onigiri-Panel und starte den Charakter-Konverter.
Mappe die Bones auf das OpenSim/SL-Rig.
Überprüfe und optimiere die Gewichte.
Exportiere als glTF.

DAZ/Avastar-Avatar konvertieren

Importiere das DAZ/Avastar-Modell.
Verwende den Charakter-Konverter und Mapper.
Passe Bone-Namen und -Hierarchie an.
Exportiere als glTF.

Tipps & Hinweise

Speichere Blender-Dateien regelmäßig als Backup.
Teste Modelle nach dem Hochladen in einer Test-Region.
Verwende Onigiri-Werkzeuge für Shape- und Gewichtsoptimierung.
Bei Problemen: siehe README, CHANGELOG oder dieses Handbuch.

Support & Community

GitHub: https://github.com/nessaki/Onigiri
Offizielle Dokumentation (Englisch): https://github.com/nessaki/Onigiri/wiki
Für Fragen und Hilfe: siehe README oder erstelle ein GitHub-Issue.

Anleitung: Export eines Mixamo-Avatars als glTF für OpenSim/Second Life
Diese Anleitung erklärt, wie man ein Mixamo-gerigtes Avatarmodell in Blender importiert, für OpenSim/Second Life vorbereitet und als glTF exportiert.

Voraussetzungen

Blender 5.0 oder neuer
Onigiri-Add-on installiert und aktiviert
Mixamo-Avatar als FBX-Datei

Schritt 1: Mixamo-Avatar importieren

Starte Blender und öffne eine neue Szene.
Gehe zu Datei > Importieren > FBX (.fbx).
Wähle deine Mixamo-Avatar-FBX-Datei aus und importiere sie.
Überprüfe, ob Modell und Rig korrekt angezeigt werden.

Schritt 2: Rig für OpenSim/Second Life vorbereiten

Wähle das importierte Armature-Objekt aus.
Öffne das Onigiri-Panel (normalerweise in den Eigenschaften oder auf der rechten Seite der 3D-Ansicht).
Wähle im Onigiri-Panel die Funktion, um auf ein OpenSim/Second-Life-kompatibles Rig zu konvertieren oder zu mappen:
- Verwende die „Charakter-Konverter“- oder „Mapper“-Funktion bei Bedarf.
- Wähle „Second Life / OpenSim“ als Zielplattform.
- Folge den Anweisungen des Add-ons, um die Bones korrekt zuzuordnen.
Überprüfe Bone-Namen und -Hierarchie. Passe sie bei Bedarf an OpenSim/SL-Standards an (z.B. „mPelvis“, „mTorso“, „mHead“, etc.).
Optional: Verwende Onigiri-Werkzeuge, um Vertexgruppen, Gewichte und Posen zu optimieren.

Schritt 3: Modell bereinigen und testen

Entferne unnötige Meshes, Bones oder Hilfsobjekte.
Überprüfe Skinning-Gewichte und Animationen (falls vorhanden).
Stelle sicher, dass sich das Modell in T-Pose oder A-Pose befindet (abhängig von der Zielplattform).

Schritt 4: Als glTF exportieren

Wähle das Armature-Objekt und das Mesh aus.
Gehe zu Datei > Exportieren > glTF 2.0 (.glb/.gltf).
Wähle die Option Ausgewählte Objekte.
Stelle sicher, dass „Animationen“ aktiviert ist, wenn du Animationen exportieren möchtest.
Wähle einen Speicherort und exportiere die Datei.

Schritt 5: In OpenSim/Second Life importieren

Verwende einen Viewer oder ein Import-Tool, das glTF unterstützt (z.B. DreamGrid, OpenSim-Distributionen mit glTF-Unterstützung).
Lade das glTF-Modell hoch und überprüfe Rigging und Animationen.
Passe Materialien und Texturen bei Bedarf an.

Tipps & Hinweise

Mixamo-Rigs müssen oft manuell auf die OpenSim/SL-Bone-Struktur gemappt werden.
Onigiri bietet Werkzeuge für automatisches und manuelles Mapping.
Teste das Modell nach dem Hochladen in einer Testregion.
Für komplexe Avatare wird empfohlen, zwischendurch als Blender-Datei zu speichern.

Fragen oder Probleme? Siehe README, CHANGELOG oder die Onigiri-Dokumentation für weitere Informationen.

PaintNet 5.x Megafilter Plugin

Fri, 26 Dec 2025 08:43:22 +0100

PaintNet 5.x Megafilter Plugin

Echtzeit Regelung, ohne dutzende Filter zu öffnen.

Basis-Anpassungen (8 Filter)

Helligkeit ✅ - Helligkeit anpassen (-100 bis +100)
Kontrast ✅ - Kontrast verstärken/reduzieren (-100 bis +100)
Sättigung ✅ - Farbsättigung anpassen (-100 bis +100)
Weichzeichner ✅ - Gaußscher Weichzeichner (Radius 0-100)
Schärfen ✅ - Schärfen-Filter (0-100)
Farbton verschieben ✅ - Hue-Rotation (-180° bis +180°)
Vignette ✅ - Randabdunklung (Strength + Radius 0.0-1.0)
Sepia ✅ - Sepia-Ton-Effekt (Intensity 0-100)

Farbfilter (4 Filter)

Graustufen ✅ - Schwarzweiß (3 Methoden: Average, Luminosity, Desaturation)
Invertieren ✅ - Farben umkehren (Intensity 0-100%)
Farbtemperatur ✅ - Warm/Kalt + Tint-Anpassung (-100 bis +100)
Kanalmixer ✅ - RGB-Kanäle einzeln anpassen (-100 bis +100)

Schärfe & Weichzeichner (3 Filter)

Bewegungsunschärfe ✅ - Motion Blur (Angle 0-360°, Distance 0-100px)
Kantenerkennung ✅ - Edge Detection mit Sobel-Operator (Threshold 0-255)
Unscharf maskieren ✅ - Professionelles Schärfen (Amount 0-500%, Radius 1-10, Threshold 0-255)

Stilisierung (4 Filter)

Posterisieren ✅ - Farbreduktion (2-256 Stufen)
Verpixeln ✅ - Pixelate-Effekt (Block Size 2-50px)
Prägen ✅ - 3D-Relief-Effekt (Angle 0-360°, Depth 0-100)
Ölgemälde ✅ - Künstlerischer Look (Brush Size 1-20, Intensity 0-100)

Tonwert-Korrekturen (4 Filter)

Belichtung ✅ - EV-Stops (-3 bis +3)
Schatten/Lichter ✅ - Dynamikbereich optimieren (je -100 bis +100)
Gamma ✅ - Gamma-Korrektur (0.1-3.0)
Tonwertkorrektur ✅ - Levels mit Black/White/Mid-Point

Spezialeffekte (4 Filter)

Glühen ✅ - Bloom/Glow-Effekt (Intensity 0-100, Radius 0-50)
Rauschen ✅ - 3 Rausch-Typen (Gaussian, Uniform, Salt&Pepper)
Chromatische Aberration ✅ - Farbversatz-Linseneffekt (Strength 0-10)
Linsenverzerrung ✅ - Barrel/Pincushion Distortion (-100 bis +100)

Download: https://github.com/ManfredAabye/PaintNet...n/releases
Sourcecode: https://github.com/ManfredAabye/PaintNet...ter-Plugin

PaintNET Plugin ORM Maps

Wed, 17 Dec 2025 00:15:31 +0100

PaintNET 5.1.x Plugin´s
PaintNET Plugin’s - ORM-Emissive, ORM-Normalmap und ORM-Generator für OpenSim und Second Life.

Die DLL liegt bereit in Release\net9.0-windows\ORMGenerator.dll. Kopiere sie nach C:\Program Files\paint.net\Effects
Starte Paint.Net
Lade oder generiere ein Bild.
In PaintNet:
ORM -> ORM MAP Generator
ORM -> ORM-Emissive
ORM -> ORM-Normalmap

PaintnetORM2.png (Größe: 220,76 KB / Downloads: 70)

Upgrade: Version 1.0.3 Echtzeit Bearbeitung und Position verändert, jetzt im eigenen ORM Verzeichnis.

Erste Release auf Github: https://github.com/ManfredAabye/PaintNET...s/releases

ERP-System-Integration

Sun, 12 Oct 2025 16:28:41 +0200

# Machbarkeitsstudie: OpenSimulator ERP-System-Integration für Virtuelle Welten

## ? Executive Summary

### Zielsetzung
Entwicklung einer ERP-Integration für virtuelle Wirtschaftssysteme am Beispiel des C# MoneyServers mit ERPNext/Odoo zur Erschließung neuer digitaler Märkte.

## ? Marktanalyse und Potenzial

### Virtuelle Wirtschaft im Überblick
```
Marktvolumen virtueller Wirtschaften (2024):
├── Second Life Economy: ~500 Mio. USD/Jahr
├── Roblox Developer Exchange: ~600 Mio. USD/Jahr
├── Fortnite Creative Economy: ~300 Mio. USD/Jahr
├── Decentraland/Web3: ~200 Mio. USD/Jahr
└── Asiatische Metaverse-Plattformen: ~1 Mrd. USD/Jahr
```

### Zielgruppen
```python
target_groups = {
"Unternehmen": [
"Virtuelle Retailer (Nike, Gucci)",
"Event-Veranstalter in Metaverse",
"Immobilienentwickler digitale Grundstücke",
"Bildungsanbieter mit VR-Training"
],
"Inhalteersteller": [
"3D-Designer und Entwickler",
"Virtual Fashion Brands",
"NFT-Künstler und Galerien",
"Metaverse Architekten"
],
"Service Provider": [
"VR-Beratungsunternehmen",
"Transaktionsdienstleister",
"Steuerberater für digitale Wirtschaft"
]
}
```

## ? Technische Machbarkeit

### 1. Systemarchitektur
```mermaid
graph TB
A[ERPNext/Odoo] --> B[Integration Layer]
B --> C[C# MoneyServer]
C --> D[Virtuelle Welt]
B --> E[Blockchain Connector]
B --> F[Payment Gateway]
E --> G[NFT Marketplace]
F --> H[Fiat Währung]
```

### 2. API-Integration
```python
class TechnicalFeasibility:
def api_compatibility_check(self):
return {
"csharp_money_server": {
"rest_api": "✅ Vollständig",
"authentication": "✅ OAuth2/JWT",
"data_formats": "✅ JSON/XML",
"rate_limiting": "✅ Konfigurierbar"
},
"erpnext_integration": {
"custom_doctypes": "✅ Möglich",
"webhooks": "✅ Verfügbar",
"real_time_sync": "✅ WebSockets",
"batch_processing": "✅ Scheduled Jobs"
},
"odoo_integration": {
"custom_modules": "✅ Standard",
"orm_integration": "✅ Native",
"qweb_reports": "✅ Templates",
"security_model": "✅ Erweiterbar"
}
}
```

### 3. Datenmodell-Erweiterungen
```python
# ERPNext Doctype Erweiterungen
required_doctypes = [
"Virtual Currency Account",
"Digital Asset Inventory",
"Metaverse Transaction",
"NFT Asset Management",
"Cross-Reality Customer",
"Virtual Event Management"
]

# Odoo Model Erweiterungen
odoo_models = [
"opensim.currency.account",
"metaverse.transaction",
"digital.asset.tracking",
"virtual.inventory",
"avatar.customer.profile"
]
```

## ? Wirtschaftliche Machbarkeit

### Investitionskosten
```python
development_costs = {
"phase_1_grundintegration": {
"entwicklung": "15.000-25.000 €",
"testing": "5.000 €",
"dokumentation": "3.000 €",
"gesamt": "23.000-33.000 €"
},
"phase_2_erweiterungen": {
"multi_currency": "8.000 €",
"nft_integration": "12.000 €",
"analytics_dashboard": "10.000 €",
"gesamt": "30.000 €"
},
"phase_3_enterprise": {
"ai_features": "25.000 €",
"blockchain": "20.000 €",
"compliance_tools": "15.000 €",
"gesamt": "60.000 €"
}
}
```

### Betriebskosten (jährlich)
```python
operational_costs = {
"server_infrastruktur": "5.000 €",
"wartung_updates": "15.000 €",
"support_service": "10.000 €",
"lizenzen_apis": "3.000 €",
"gesamt": "33.000 €/Jahr"
}
```

### Erlöspotenziale
```python
revenue_streams = {
"lizenzmodell": {
"basic": "99 €/Monat",
"professional": "299 €/Monat",
"enterprise": "999 €/Monat",
"potenzial_jahr_1": "120.000 €",
"potenzial_jahr_3": "500.000 €"
},
"transaktionsgebuehren": {
"prozent_satz": "0.5-1%",
"volumen_annahme": "1 Mio. €/Jahr",
"ertrag_potenzial": "5.000-10.000 €/Jahr"
},
"service_dienstleistungen": {
"implementierung": "10.000 €/Projekt",
"schulung": "2.000 €/Tag",
"wartung": "15% Lizenzkosten"
}
}
```

## ⚖️ Rechtliche und Compliance-Machbarkeit

### Kritische Bereiche
```python
compliance_requirements = {
"finanzverwaltung": [
"Umsatzsteuer auf virtuelle Dienstleistungen",
"Gewinnermittlung digitale Assets",
"Geldwäscheprävention (AML)",
"Steuerliche Behandlung virtueller Währungen"
],
"datenschutz": [
"DSGVO für Avatar-Daten",
"Cross-Border Data Transfer",
"Recht auf Vergessenwerden",
"Data Processing Agreements"
],
"vertragsrecht": [
"EULA für virtuelle Güter",
"Nutzungsrechte digitale Assets",
"Haftung für Systemausfälle",
"Internationale Jurisdiktion"
]
}
```

## ? Use Cases und Geschäftsszenarien

### 1. Virtueller Einzelhandel
```python
virtual_retail_scenario = {
"prozess": "Nike Virtual Store in Roblox",
"integration": [
"ERP: Lagerbestandsmanagement",
"CRM: Kundenpräferenzen Avatare",
"POS: Virtuelle Kassenintegration",
"Analytics: Cross-Reality Kundenverhalten"
],
"mehrwert": "Nahtlose Integration realer und virtueller Verkäufe"
}
```

### 2. Digitale Event-Wirtschaft
```python
event_management_scenario = {
"anwendung": "Virtual Concert Management",
"funktionen": [
"Ticketverkauf mit NFT-Integration",
"Merchandising virtuelle Güter",
"Royalty-Verteilung an Künstler",
"Echtzeit-Umsatzreporting"
],
"skalierung": "Globale Events ohne physische Limits"
}
```

### 3. Unternehmensinterne Anwendungen
```python
corporate_scenario = {
"use_case": "VR Training mit ERP-Tracking",
"integration": [
"Schulungsbudget-Verwaltung",
"Teilnehmer-Fortschrittsmonitoring",
"Skill-Zertifizierung",
"ROI-Berechnung Trainingseffektivität"
],
"effizienz": "Reduzierte Reisekosten, bessere Lernresultate"
}
```

## ? Risikoanalyse

### Technische Risiken
```python
technical_risks = {
"hoch": [
"API-Änderungen Plattform-Betreiber",
"Skalierbarkeit bei Massentransaktionen",
"Datenkonsistenz bei Netzwerkproblemen"
],
"mittel": [
"Sicherheit virtueller Wallets",
"Performance Echtzeit-Synchronisation",
"Datenmigration bestehender Systeme"
],
"gering": [
"Browser-Kompatibilität Frontend",
"Backup-Wiederherstellung",
"Dokumentation Updates"
]
}
```

### Marktrisiken
```python
market_risks = {
"regulatorisch": "Änderungen Krypto-Regulierung",
"akzeptanz": "Langsame Enterprise-Adoption Metaverse",
"konkurrenz": "Großtech-Lösungen (Microsoft, Meta)",
"technologisch": "Platform-Shifts im Metaverse"
}
```

## ? Umsetzungsplan

### Phase 1: MVP (3-4 Monate)
```python
mvp_milestones = [
"Monat 1: Grundintegration C# MoneyServer",
"Monat 2: Basis-ERP-Funktionen (Konten, Transaktionen)",
"Monat 3: Reporting und Dashboard",
"Monat 4: Pilotkunden-Integration und Testing"
]
```

### Phase 2: Erweiterung (6 Monate)
```python
enhancement_phase = [
"Multi-Währungs-Support",
"NFT-Asset-Management",
"Erweiterte Analytics",
"Compliance-Features"
]
```

### Phase 3: Enterprise (12 Monate)
```python
enterprise_features = [
"AI-gestützte Prognosen",
"Blockchain-Integration",
"Multi-Plattform-Support",
"Global Compliance Framework"
]
```

## ? Empfehlungen

### 1. Technologische Entscheidungen
```python
recommendations = {
"erp_system": "ERPNext für Startups, Odoo für Enterprises",
"entwicklungsansatz": "Microservices-Architektur",
"sicherheit": "Zero-Trust Security Model",
"skalierung": "Cloud-native Implementierung"
}
```

### 2. Geschäftsstrategie
```python
business_strategy = {
"markteintritt": "Nische Virtual Retail -> Enterprise",
"preisstrategie": "Value-based Pricing",
"partner": "Metaverse-Plattformen, Steuerberater, Tech-Provider",
"expansion": "EU -> Nordamerika -> Asien"
}
```

## ✅ Fazit der Machbarkeitsstudie

### Machbarkeit
- **Technisch**: ✅ Hoch - Standardschnittstellen verfügbar
- **Wirtschaftlich**: ✅ Mittel - Investition mit gutem ROI-Potenzial
- **Rechtlich**: ⚠️ Herausfordernd - aber managbar mit Expertise
- **Operativ**: ✅ Hoch - Ähnlich anderen ERP-Integrationen

### Erfolgskritische Faktoren
1. **Frühe Compliance-Einbindung**
2. **Skalierbare Architektur**
3. **Starke Partner-Netzwerke**
4. **Agile Marktanpassungsfähigkeit**

### Next Steps
1. **Proof-of-Concept mit Pilotkunden**
2. **Detailierte Rechtsprüfung**
3. **Technische Prototyp-Entwicklung**
4. **Business Plan Verfeinerung**

Die Integration von ERP-Systemen mit virtuellen Wirtschaften stellt eine **realistische und vielversprechende** Geschäftschance dar, die strategische Wettbewerbsvorteile in der digitalen Transformation bietet.

GLTF-Packer

Sat, 04 Oct 2025 00:50:47 +0200

PBR Material Maker Dotnet 10 mit Texturgenerator.
# DOTNET 10.0 Version von GLTF Packer (Fork von Captain Ai)

Visual Studio 2026 – Windows 11 – .NET 10.0

Diese Version erstellt automatisch nicht vorhandene PBR-Bestandteile (BaseColor, Normal, Occlusion, Roughness, Metallic, Emission, Alpha) und speichert sie im Zielverzeichnis. Diese werden aus der Albedo berechnet.

packer.png (Größe: 220,27 KB / Downloads: 250)

## Features

- Automatische Erzeugung fehlender PBR-Texturen (weiß/schwarz oder generiert)
- Normalmap-Generierung aus Albedo mit Prägung
- Unterstützung für Drag & Drop von Texturen
- Anpassbare Auflösung für alle Maps
- GLTF-Export mit allen relevanten Textur-Referenzen
- Kompatibel mit Windows 11 und Visual Studio 2026 (.NET 10.0)

## Installation

1. Projekt mit Visual Studio 2026 öffnen.
2. Abhängigkeiten installieren (NuGet: Newtonsoft.Json).
3. Anwendung kompilieren und starten.

## Verwendung

1. Ziehe die gewünschte Albedo-Textur per Drag & Drop in das Fenster.
2. Weitere Maps werden automatisch erkannt oder generiert.
3. Wähle die gewünschte Auflösung.
4. Klicke auf „Save“, um die GLTF-Datei und alle Texturen zu exportieren.

## Disclaimer

GLTF Packer steht in keiner Verbindung zu KhronosGroup, glTF, Linden Lab, SecondLife oder OpenSim. Es handelt sich um Drittanbieter-Software.

## Lizenz

Siehe LICENSE-Datei im Repository.

## Fertige Windows Version Download

opensim user accounts tests

Mon, 02 Sep 2024 12:07:53 +0200

opensim_user_accounts
OpenSimulator Benutzeraccounts erstellen, ändern und löschen.
Anleitung und Sourcecode auf Github.
https://github.com/ManfredAabye/opensim_user_accounts

OpenSimRegionConfig

Sat, 31 Aug 2024 15:30:54 +0200

Anleitung zur Nutzung des Regionenkonfigurators

Hier ist eine Schritt-für-Schritt-Anleitung zur Verwendung des Python-Skripts, das eine GUI-Anwendung erstellt, um Regionskonfigurationen zu generieren.

### Voraussetzungen:
- **Python 3.x**: Stelle sicher, dass Python auf deinem System installiert ist.
- **Tkinter**: Tkinter ist normalerweise in Python vorinstalliert. Falls es fehlt, installiere es mit:
```bash
sudo apt-get install python3-tk
```

### 1. Überblick:
Dieses Skript erstellt eine grafische Benutzeroberfläche (GUI), mit der du verschiedene Einstellungen für Regionen vornehmen kannst, die anschließend in einer `.ini`-Konfigurationsdatei gespeichert werden. Jede Region hat verschiedene Parameter wie Größe, UUID, Position (Location) und viele andere, die du individuell konfigurieren kannst.

### 2. Skript ausführen:
1. **Python-Datei erstellen**: Erstelle eine Datei namens `region_config_app.py` und kopiere den bereitgestellten Python-Code in diese Datei.
2. **Skript starten**: Öffne ein Terminal oder eine Eingabeaufforderung und navigiere zu dem Verzeichnis, in dem sich die Datei befindet. Führe das Skript mit folgendem Befehl aus:
```bash
python region_config_app.py
```
3. **GUI-Anwendung**: Nach dem Ausführen öffnet sich ein Fenster mit der Benutzeroberfläche.

### 3. Verwendung der GUI:
1. **Felder ausfüllen**: Die Benutzeroberfläche zeigt verschiedene Felder an, in denen du die gewünschten Parameter für eine Region anpassen kannst.
- **Region Name**: Name der Region.
- **Region UUID**: Eindeutige Identifikationsnummer der Region.
- **Location**: Der Standort der Region (x, y), standardmäßig auf `1000,1000` gesetzt. Es wird automatisch angepasst, wenn du eine neue Region hinzufügst.
- **Size X, Y, Z**: Dimensionen der Region.
- **Internal Port**: Interner Netzwerkport.
- **External Host**: Externer Hostname.
- **Maptile UUID**: UUID für die Kartendatei, die die Region repräsentiert. Wird automatisch auf die Region UUID gesetzt.
- **Weitere Parameter**: Andere Einstellungen wie Maximalanzahl an Prims, Agenten, ScopeID usw.
2. **Region hinzufügen**: Klicke auf die Schaltfläche **"Add Region"**. Dadurch wird eine neue Region mit einer eigenen UUID und einem neuen Standort (basierend auf einer spiralförmigen Berechnung) erstellt.
3. **Konfiguration speichern**: Nachdem du die gewünschten Regionen hinzugefügt hast, klicke auf **"Save Config"**, um die Konfigurationen in einer `.ini`-Datei zu speichern. Wähle einen Speicherort und einen Dateinamen.

### 4. Ergebnis:
- Die erstellte `.ini`-Datei enthält Abschnitte für jede Region mit den von dir festgelegten Konfigurationen. Jede Region erhält eine eigene `Location`, `UUID` und andere Parameter.

### 5. Beispielhafte INI-Datei:
Die gespeicherte Datei könnte in etwa so aussehen:

```ini

PHP-Code:
[TestRegion_1]
RegionUUID = 123e4567-e89b-12d3-a456-426614174000
Location = 1000,1000
SizeX = 256
SizeY = 256
SizeZ = 256
InternalPort = 9050
ExternalHostName = SYSTEMIP
MaxPrims = 100000
MaxAgents = 99
MaptileStaticUUID = 123e4567-e89b-12d3-a456-426614174000
...

[TestRegion_2]
RegionUUID = 223e4567-e89b-12d3-a456-426614174001
Location = 1001,1001
SizeX = 256
SizeY = 256
SizeZ = 256
InternalPort = 9051
ExternalHostName = SYSTEMIP
MaxPrims = 100000
MaxAgents = 99
MaptileStaticUUID = 223e4567-e89b-12d3-a456-426614174001 

...
```

### 6. Erweiterungen und Anpassungen:
Du kannst den Code anpassen, um zusätzliche Parameter hinzuzufügen oder die Art und Weise zu ändern, wie `Locations` berechnet werden.

### 7. Fehlerbehebung:
- **Tkinter nicht gefunden**: Stelle sicher, dass Tkinter installiert ist.
- **INI-Datei wird nicht gespeichert**: Überprüfe die Dateiberechtigungen im Zielverzeichnis.

Mit dieser Anleitung solltest du in der Lage sein, das Skript erfolgreich zu verwenden und benutzerdefinierte Konfigurationen für Regionen zu erstellen und zu verwalten.

Sourcecode:

PHP-Code:
import tkinter as tk
from tkinter import messagebox, filedialog
import configparser
import uuid
import math

class RegionConfigApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Region Configurations")

        # Set window size
        self.root.geometry("450x700")

        # Initialize variables with default values
        self.region_name = tk.StringVar(value="TestRegion")
        self.region_uuid = tk.StringVar(value=str(uuid.uuid4()))
        self.maptile_uuid = tk.StringVar(value=self.region_uuid.get())
        
        # Location variable for grid position
        self.location = tk.StringVar(value="1000,1000")
        
        self.size_x = tk.IntVar(value=256)
        self.size_y = tk.IntVar(value=256)
        self.size_z = tk.IntVar(value=256)
        self.internal_port = tk.IntVar(value=9050)
        self.external_host = tk.StringVar(value="SYSTEMIP")
        self.max_prims = tk.IntVar(value=100000)
        self.max_agents = tk.IntVar(value=99)
        self.internal_address = tk.StringVar(value="0.0.0.0")
        self.allow_alt_ports = tk.BooleanVar(value=False)
        self.non_physical_prim_max = tk.IntVar(value=256)
        self.physical_prim_max = tk.IntVar(value=64)

        # New variables for additional settings
        self.clamp_prim_size = tk.BooleanVar(value=False)
        self.max_prims_per_user = tk.IntVar(value=-1)
        self.scope_id = tk.StringVar(value=self.region_uuid.get())
        self.region_type = tk.StringVar(value="Mainland")
        self.render_min_height = tk.IntVar(value=-1)
        self.render_max_height = tk.IntVar(value=100)
        self.maptile_static_file = tk.StringVar(value="SomeFile.png")
        self.master_avatar_first_name = tk.StringVar(value="John")
        self.master_avatar_last_name = tk.StringVar(value="Doe")
        self.master_avatar_sandbox_password = tk.StringVar(value="passwd")

        self.region_count = 0  # Startet bei 0
        self.angle = 0
        self.radius = 1  # Initialer Radius
        self.locations = []  # Liste für die Locations aller Regionen

        # Trace changes to region_uuid to update maptile_uuid accordingly
        self.region_uuid.trace_add('write', self.update_maptile_uuid)

        # Build the UI
        self.build_ui()

    def update_maptile_uuid(self, *args):
        self.maptile_uuid.set(self.region_uuid.get())

    def build_ui(self):
        canvas = tk.Canvas(self.root)
        scrollbar = tk.Scrollbar(self.root, orient="vertical", command=canvas.yview)
        scrollable_frame = tk.Frame(canvas)

        scrollable_frame.bind(
            "",
            lambda e: canvas.configure(
                scrollregion=canvas.bbox("all")
            )
        )

        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)

        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")

        fields = [
            ("Region Name:", self.region_name),
            ("Region UUID:", self.region_uuid),
            ("Location:", self.location),  # Location field added here
            ("Size X:", self.size_x),
            ("Size Y:", self.size_y),
            ("Size Z:", self.size_z),
            ("Internal Port:", self.internal_port),
            ("External Host:", self.external_host),
            ("Max Prims:", self.max_prims),
            ("Max Agents:", self.max_agents),
            ("Maptile UUID:", self.maptile_uuid),
            ("Internal Address:", self.internal_address),
            ("Allow Alternate Ports:", self.allow_alt_ports),
            ("Non Physical Prim Max:", self.non_physical_prim_max),
            ("Physical Prim Max:", self.physical_prim_max),
            ("Clamp Prim Size:", self.clamp_prim_size),
            ("Max Prims Per User:", self.max_prims_per_user),
            ("Scope ID:", self.scope_id),
            ("Region Type:", self.region_type),
            ("Render Min Height:", self.render_min_height),
            ("Render Max Height:", self.render_max_height),
            ("Maptile Static File:", self.maptile_static_file),
            ("Master Avatar First Name:", self.master_avatar_first_name),
            ("Master Avatar Last Name:", self.master_avatar_last_name),
            ("Master Avatar Sandbox Password:", self.master_avatar_sandbox_password),
        ]

        for idx, (label_text, var) in enumerate(fields):
            if isinstance(var, tk.BooleanVar):
                tk.Checkbutton(scrollable_frame, text=label_text, variable=var).grid(row=idx, column=0, columnspan=2, sticky=tk.W, pady=2, padx=5)
            else:
                tk.Label(scrollable_frame, text=label_text).grid(row=idx, column=0, sticky=tk.W, pady=2, padx=5)
                entry = tk.Entry(scrollable_frame, textvariable=var, width=40)
                entry.grid(row=idx, column=1, sticky=tk.W, pady=2, padx=5)

        button_frame = tk.Frame(scrollable_frame)
        button_frame.grid(row=len(fields), column=0, columnspan=2, pady=10)

        tk.Button(button_frame, text="Add Region", command=self.add_region).pack(side="left", padx=10)
        tk.Button(button_frame, text="Save Config", command=self.save_config).pack(side="left", padx=10)

    def next_flower_spiral_location(self):
        # Berechnung der nächsten Position in der spiralförmigen, blütenartigen Anordnung
        self.angle += 137.5  # Goldener Winkel in Grad
        radians = math.radians(self.angle)
        location_x = 1000 + int(self.radius * math.cos(radians))
        location_y = 1000 + int(self.radius * math.sin(radians))
        self.radius += 1  # Erhöhe den Radius schrittweise für den nächsten Punkt
        return location_x, location_y

    def add_region(self):
        location = self.next_flower_spiral_location()
        self.locations.append(location)

        new_uuid = str(uuid.uuid4())

        self.region_count += 1
        self.region_name.set(f"TestRegion_{self.region_count}")
        self.region_uuid.set(new_uuid)
        self.internal_port.set(self.internal_port.get() + 1)

        self.location.set(f"{location[0]},{location[1]}")  # Update the location

        messagebox.showinfo("Region Added", f"Region {self.region_name.get()} hinzugefügt. Location: ({location[0]},{location[1]})")

    def save_config(self):
        filename = filedialog.asksaveasfilename(defaultextension=".ini", filetypes=[("INI files", "*.ini")])
        if filename:
            config = configparser.ConfigParser()

            for i in range(1, self.region_count + 1):
                if i == 1:
                    region_name = self.region_name.get()
                    region_uuid = self.region_uuid.get()
                    location_x, location_y = map(int, self.location.get().split(','))  # Erste Region
                else:
                    region_name = f"TestRegion_{i}"
                    region_uuid = str(uuid.uuid4())
                    location_x, location_y = self.locations[i-1]  # Spezielle Location für jede Region

                config[region_name] = {
                    "RegionUUID": region_uuid,
                    "Location": f"{location_x},{location_y}",
                    "SizeX": self.size_x.get(),
                    "SizeY": self.size_y.get(),
                    "SizeZ": self.size_z.get(),
                    "InternalPort": self.internal_port.get() + (i - 1),
                    "ExternalHostName": self.external_host.get(),
                    "MaxPrims": self.max_prims.get(),
                    "MaxAgents": self.max_agents.get(),
                    "MaptileStaticUUID": self.maptile_uuid.get(),
                    "InternalAddress": self.internal_address.get(),
                    "AllowAlternatePorts": self.allow_alt_ports.get(),
                    "NonPhysicalPrimMax": self.non_physical_prim_max.get(),
                    "PhysicalPrimMax": self.physical_prim_max.get(),
                    "ClampPrimSize": str(self.clamp_prim_size.get()),
                    "MaxPrimsPerUser": self.max_prims_per_user.get(),
                    "ScopeID": self.scope_id.get(),
                    "RegionType": self.region_type.get(),
                    "RenderMinHeight": self.render_min_height.get(),
                    "RenderMaxHeight": self.render_max_height.get(),
                    "MaptileStaticFile": self.maptile_static_file.get(),
                    "MasterAvatarFirstName": self.master_avatar_first_name.get(),
                    "MasterAvatarLastName": self.master_avatar_last_name.get(),
                    "MasterAvatarSandboxPassword": self.master_avatar_sandbox_password.get(),
                }

            with open(filename, 'w') as configfile:
                config.write(configfile)
            messagebox.showinfo("Gespeichert", "Konfiguration erfolgreich gespeichert.")

if __name__ == "__main__":
    root = tk.Tk()
    app = RegionConfigApp(root)
    root.mainloop() 

Sourcecode als Text:
OpenSimRegionConfig5.py.txt (Größe: 8,96 KB / Downloads: 243)

OAR Converter

Fri, 26 Jul 2024 10:43:16 +0200

hat jemand erfahrung mit OAR Converter ?

https://aiaustin.wordpress.com/2015/10/2...interface/

https://www.nsl.tuis.ac.jp/xoops/modules...0Converter

Das soll ein tolles tool sein mit dem man OAR dateien in Collada für Unity unwandeln kann, entwikkelt an einer Universität in Japan.
Prims, Sculpties und terraformtes Land sollen automatisch in collada umgeformt werden.

hier ein video wie das geht : https://www.youtube.com/watch?v=LUhqNJHLCuM

Leider scheint die software seit 2020 etwas verwarlost. Der source code ist noch da, aber man kann keine .EXE für windows mehr runterladen. Ich hab den eindruck das projekt stirbt langsam, vielleicht kann man noch etwas retten.

https://www.nsl.tuis.ac.jp/svn/linux/oarconv/trunk/

--------------

UPDATE:

ah das runterladen vom exe geht doch, wenn man auf das kleine Ikon klickt

Manni bei Gitlab

Wed, 24 Apr 2024 22:22:27 +0200

Ich habe erst einmal das opensimMULTITOOL und den OpenSimCurrencyServer-DOTNET
bei Gitlab zum Download bereitgestellt, beides ist DOTNET 8 kompatibel.

Link: https://gitlab.com/ManfredAabye

World Heightmap Generator

Fri, 26 May 2023 14:21:22 +0200

WGEN 0.3.1 – ein einfacher Höhenkartengenerator

Es gibt viele großartige Geländegeneratoren, aber die meisten davon verfügen über eine kostenlose Version mit einer Geländegrößenbeschränkung.

Dies ist ein viel einfacherer Generator, aber er kann Karten in beliebig großer Größe exportieren.

Github (Herunterladen - entpacken - starten):
https://github.com/jice-nospam/wgen/releases/tag/v0.3.1

Deutsche Anleitung:
https://eu2.contabostorage.com/52253033f...erator.pdf

Fragen zum Thema Mesh

Fri, 24 Mar 2023 11:01:46 +0100

Hey Zusammen,

Ich habe mal eine Frage, ist es Technisch möglich aus einer 2D Grafik also einem Bild ein Mesh Objekt zu erzeugen?

Mesh Texte

Tue, 17 Jan 2023 14:23:26 +0100

Hey,
Ich wollte mal fragen ob mir vielleicht einmal einer erklären kann wie man mesh texte erstellen, ich gab mir bereits blender herruntergeladen. Aber ich komm damit nicht klar.
Deswegen wollte ich erst einfache sachen machen, wie eben einen Text.
Und was man beim upload des collada files beachten muss.
Vielleicht kann das ja jemmand erklären wäre super.

Metahuman Avatare

Tue, 13 Dec 2022 16:14:57 +0100

Ich bastell gerade mit Blender-Buddy Avatare.
Von etwas über 100, die ich bis jetzt erstellt habe, sind 55 so lala benutzbar.
Die haben erst einmal keine Gesichtsmuskeln nur Bento Hände.
Ich teste gerade, wie man am besten Metahuman Avatare nach OpenSim portieren kann.

Metahuman Avatare benötigt (nicht mit Makehuman verwechseln):

MetaHumanCreator.jpg (Größe: 125,23 KB / Downloads: 328)

Metahuman UE5
https://metahuman.unrealengine.com/

Unreal Engine UE5
https://www.unrealengine.com

Quixel Bridge UE4
https://quixel.com/bridge
Ab Unreal Engine 5 ist das eine Erweiterung, die man im Asset Store bekommt.
https://www.unrealengine.com/marketplace/en-US/store

Quixel Mixer
https://quixel.com/mixer

In Blender können die Metahuman Avatare für OpenSim angepasst werden.
Für Second Life ist das Kommerziell, da kenn ich mich nicht mit aus.

Ich benutze zum anpassen Blender 3.x+ und Blender Buddy
Blender Buddy kostet ca` 33€.

MetaHumanCreator5.jpg (Größe: 85,75 KB / Downloads: 305)

P.S. Die Avatare sehen hier auf den Bildern nicht so Real aus, Fototechnisch bedingt.