- 
-
-
-In this example ``Camera`` ``and Const Collection 1`` is in ``Script_Ignore`` and will be displayed in every NFT generated. The collection ``Cube`` represents an attribute, and the collections ``Cube_1_33``, ``Cube_2_33``, ``Cube_3_33``, and ``Cube_4_1`` are the variants of that attribute. Notice that each variant of Cube has an incrementing number representing the order of the variants. The numbers ``33``, ``33``, ``33``, and ``1`` represent the percentage chance that variant will get chosen if ``enableRarity`` is set to ``True``.
-
-## Customizing the config.py file
-
-After installation, open the Blend_My_NFTs folder. You will need to change variables in the config.py file with a text editor or IDE; I recomend Visual Studio Code, but Blender has a bilt in Text Editor for ease of use. config.py is where you can customize aspects of your NFT collection and how it is generated.
-
-Description of customisable variables to generate images:
-
-``nftName`` - A string representing name of the file exported by Blend_My_NFTs (REQUIRED)
-
-
-``imageFileFormat`` - A string representing the image file format that Blend_My_NFTs will export generated images as: (REQUIRED)
-
- Type the exact name provided below in the '' for the imageFileFormat:
-
- 'JPEG' - Exports the .jpeg format
-
- 'PNG' - Exports the .png format
-
- Visit https://docs.blender.org/api/current/bpy.types.Image.html#bpy.types.Image.file_format for a complete list of file formats supported by Blender. Enter the file extension exactly as specified in the Blender API documentation.
-
-``animationFileFormat`` - A string representing the animations file format that Blend_My_NFTs will export generated animations as: (REQUIRED)
-
- Type the exact name provided below in the '' above:
-
- AVI_JPEG - Exports the .avi jpeg format
-
- AVI_RAW - Exports the .avi raw format
-
- FFMPEG - Exports the .ffmpeg format
-
- Visit https://docs.blender.org/api/current/bpy.types.Image.html#bpy.types.Image.file_format for a complete list of file formats supported by Blender. (These are the Blender only supported animation formats).
-
-``modelFileFormat`` - A string representing the 3D Models file format that Blend_My_NFTs will export generated 3D Modles as: (REQUIRED)
-
- Type the exact name provided below in the '' above:
-
- fbx - The .FBX file format
-
- glb - The .glb file format
-
- obj - The .obj file format *Exports both a .obj and a .mtl files for the same generated object
-
- x3d - The .x3d file format
-
- Visit https://docs.blender.org/api/current/bpy.ops.export_scene.html?highlight=export_scene#module-bpy.ops.export_scene
- for a complete list of object formats supported by Blender.
-
-
-``save_path_mac`` - A string representing the save path for Blend_My_NFTs if you are using MacOS: (REQUIRED - if using MacOS)
-
- Example Mac: /Users/Path/to/Blend_My_NFTs
-
-
-``save_path_windows`` - A string representing the save path for Blend_My_NFTs if you are using Windows: (REQUIRED - if using Windows)
-
- Example Windows: C:\Users\Path\to\Blend_My_NFTs
-
-
-``save_path_linux`` - A string representing the save path for Blend_My_NFTs if you are using Linux OS (REQUIRED - if using Linux)
- Example Linux: /home/Path/to/Blend_My_NFTs
-
-
-``maxNFTs`` - A positive integer representeing the number of NFTs to generate. (REQUIRED)
-
-
-``nftsPerBatch`` - A positive integer representing the number of NFTs per batch. (REQUIRED)
-
-
-``renderBatch`` - A positive integer representing the batch number to render if ``renderImage`` is set to True. (REQUIRED)
-
-
-``enableRarity`` - A boolean value, when set to True, rarity percentage will be taken into account when generating NFT DNA and exporting to NFTRecord.json
-
-
-``enableExporter`` - A Boolean value, when set to True, will export Images and or 3D models when main.py is run in Blender. (Turned on after NFTRecord.json and appropriate batches are generated with main.py)
-
-
-``enableImages`` - A boolean value, when set to True with ``enableExporter = True`` will export images.
-
-
-``enableAnimations`` - A boolean value, when set to True with ``enableExporter = True`` will export animations.
-
-
-``enableModelsBlender`` - A boolean value, when set to True with ``enableExporter = True`` will export 3D models.
-
-
-- Note that ``enableImages``, ``enableModelsBlender``, and ``enableAnimations`` can run at the same time. Both 3D Models, Animations, and Images will be exported. (One of the above is REQUIRED to generate NFT files)
-
-
-``refactorBatchOrder`` - A boolean value, when set to True will combine NFT Batch# folders into a folder called ``Complete_Collection`` when main.py is run in Blender. Running main.py with this variable set to True will aslo generate meta data formats if the desired formats below are also set to True.
-
-
-``cardanoMetaData`` - A boolean value, when set to True will generate a folder containing Cardano meta data json files for each NFT file. Generates when main.py is run with ``refactorBatchOrder`` is set to True.
-
-
-``solanaMetaData`` - A boolean value, when set to True will generate a folder containing Solana meta data json files for each NFT file. Generates when main.py is run with ``refactorBatchOrder`` is set to True.
-
-
-``erc721MetaData`` - A boolean value, when set to True will generate a folder containing ERC721 (Ethereum) meta data json files for each NFT file. Generates when main.py is run with ``refactorBatchOrder`` is set to True.
-
-
-``turnNumsOff`` - A boolean value, when set to True will remove numbers and underscores in the names of Variants when NFT meta data is generated. Works after ``refactorBatchOrder`` is ran in main.py.
-
-
-``metaDataDescription`` - A string value, sets the Description variable in the BMNFTs meta data file format. Can be used in a modifed version of metaData.py to fill in Description varaibles in other meta data formats.
-
-
-``enableGeneration`` - A boolean value, when set to True, applies and takes into account colour or material variants in the NFT DNA. (Optional)
-
-
-``generationType`` - A string value, takes ``color`` or ``material`` as input. Determines if extra variatns are generated with colours or material textures. (Optional)
-
-
-``rgbaColorList#`` - A list containing tuples representing the RGBA colour values assigned to a given object in ``colorList``. (Optional)
-
-
-``materialList#`` - A list containing strings representing the names of materials in blender: (Optional)
-
- These materials must be in your Current Files' Materials. Make sure that you've set your materials as "fake user". The collections below are Current Files' Materials. You can put as many or as little materials values in these lists as you would like. You can create any number of materialLists and assign them to any number of collections that you would like. Each set of materialLists assigned to an object by collection name in the materialList will act like an attribute and create a unique variant of that item.
-
-
-``colorList`` - A dictionary which the keys are the names of variants, and the items are the ``rgbaColorList#`` or ``materialList#``: (Optional)
-
- The rgbaColorList# deterimnes the colours that the variants will change to. This creates new variants with those RGBA colour values.
-
-
-``enableResetViewport`` - A boolean value, when set to True, resets the veiwport of all cameras not in Script_Ignore. (Optional)
-
-``enable3DModels`` - A boolean value, when set to True, will generate all possible combinations of 3D models when working with an external repository of 3D models in ``3D_Model_Input``.
-
-``runPreview`` - A boolean value, when set to True, will run a shell of all main modules to generate NFT files. Will print useful numbers and values in the console to help you create your NFT collection.
-
-
-``maxNFTsTest`` - A positive integer representing the number of NFTs to create during the test. This number aids in the estimation of complete collection creation; the higher this number, the more accurate the estimation.
-
-
-``checkDups`` - A boolean value, when set to True, will print the number of duplicate NFTs found in the NFTRecord.json file. This file is provided for transparency, it is impossible for duplicates to be made with the current code in the DNA_Generator.py
-
-
-``checkRarity`` - A boolean value, when set to True, will print the true rarity data in the Blender System Console, this data will be saved to a RarityData.json file in the Blend_My_NFTs folder. This file is provided for transparency. The accuracy of the rarity values you set in your .blend file as outlined in the below are dependent on the maxNFTs, and the maximum number of combinations of your NFT collection.
-
-
-## Running main.py - Generating NFTRecord and Batches
-
-Before you can render iamges you need to generate a list of NFT DNA then split it up into batches to render more easily. These will take the form of the NFTRecord.json file, and a list of Batch#.json files.
-
-``NFTRecord.json`` - This file contains a list of all NFT DNA, this list is limited by ``nftMax`` in config.py.
-
-``Batch#.json`` - These files contain peices of NFTRecord.json selected at random and sent to a batch containing ``nftsPerBatch`` number of DNA.
-
-Before running main.py, ensure these variables are set properly or else the script will not work:
-
-- ``nftName``
-- ``save_path_mac`` or ``save_path_windows``
-- ``maxNFTs``
-- ``nftsPerBatch``
-- ``enableExporter = False``
-
-Steps to generate NFTRecord and Batches:
-
-1. In your .blend file open the ``Scripting Tab`` in the menu of Blender:
-
-
-
-2. Click the "Open" button in the Blender Text Editor:
-
-
-
-3. With the Blender File View open, navigate to the Blend_My_NFTs folder, navigate to the ``src`` folder, then open main.py.
-
-
-
-5. To run main.py click the run button shown circled below:
-
-
-
-If you correctly formated your .blend file, you will now have two file types; an NFTRecord.json, and a number of Batch#.json files located in the ``Batch_Json_files`` folder.
-
-## Running main.py - Generating Image Batches
-
-**For this section, ensure you have generated NFTRecord.json and Batch#.json files before taking the following steps**
-
-Steps to Generate Images:
-
-1. Ensure all manditory variables have been filed in (all found in config.py):
-- ``nftName``
-- ``save_path_mac`` or ``save_path_windows``
-- ``maxNFTs``
-- ``nftsPerBatch``
-- ``renderBatch``
-
-2. Run main.py in Blender with ``enableExporter`` set to ``False`` in config.py. This will generate the NFTRecord.json and Batch#.json files.
-
-3. Set ``renderBatch`` to the batch number you wish to render in config.py.
-
-4. Set ``enableExporter`` to ``True`` in config.py.
-
-5. Set ``enableImages`` to ``True`` in config.py.
-
-6. Run main.py in the Blender Scripting Tab. This will now generate Images.
-
-
-
-Reapeat the steps above for each Batch to generate the complete NFT collection.
-
-## Summery: The order to run main.py to Generate Image Batches
-
-Run the scripts in the following order:
-1. main.py - With ``renderImage`` set to ``False`` in the config.py: Generates the data for your NFT collection.
-2. main.py - With ``renderImage`` set to ``True`` in the config.py: Renders images in a batch specified by ``renderBatch``.
-
-## Running main.py - Generating Animation Batches
-
-Steps to Generate Animations:
-
-1. Ensure all manditory variables have been filed in (all found in config.py):
-- ``nftName``
-- ``save_path_mac`` or ``save_path_windows``
-- ``maxNFTs``
-- ``nftsPerBatch``
-- ``renderBatch``
-
-2. Run main.py in Blender with ``enableExporter`` set to ``False``. This will generate the NFTRecord.json and Batch#.json files.
-
-3. Set ``animationFileFormat`` to the animation file format you wish to export in config.py.
-
-4. Set ``enableAnimations`` to ``True`` in config.py.
-
-5. Set ``enableExporter`` to ``True`` in config.py.
-
-6. Run main.py in the Blender Scripting Tab. This will now generate Animations.
-
-
-
-Reapeat the steps above for each Batch to generate the complete NFT collection.
-
-## Summery: The order to run main.py to Generate Animation Batches
-
-Run the scripts in the following order:
-1. main.py - With ``enableExporter`` set to ``False`` in config.py: Generates the data for your NFT collection.
-2. main.py - With ``enableExporter`` and ``enableAnimations`` set to ``True`` in config.py: Renders and compiles animations.
-
-## Running main.py - Generating 3D Model Batches from a .blend file
-
-Youtube tutorial for generating 3D models: https://www.youtube.com/watch?v=rRs0lN5huDk&t=1s
-
-Steps to Generate 3D models:
-
-1. Ensure all manditory variables have been filed in (all found in config.py):
-- ``nftName``
-- ``save_path_mac`` or ``save_path_windows``
-- ``maxNFTs``
-- ``nftsPerBatch``
-- ``renderBatch``
-
-2. Run main.py in Blender with ``enableExporter`` set to ``False``. This will generate the NFTRecord.json and Batch#.json files.
-
-3. Set ``modelFileFormat`` to the 3D Model file format you wish to export in config.py.
-
-4. Set ``enableModelsBlender`` to ``True`` in config.py.
-
-5. Set ``enableExporter`` to ``True`` in config.py.
-
-6. Run main.py in the Blender Scripting Tab. This will now generate 3D Models.
-
-
-
-## Summary: The order to run main.py to Generate 3D Model Batches:
-
-run the scripts in the following order:
-1. main.py - With ``enableExporter`` set to ``False`` in config.py: Generates the data for your NFT collection.
-2. main.py - With ``enableExporter`` and ``enableModelsBlender`` set to ``True`` in config.py: Exports 3D models.
-
-# Generating 3D Models with external 3D Models
-
-This youtube tutorial goes over the basic setup discussed in this section: https://www.youtube.com/watch?v=NonORFpVhLw (This video is out of date but may be of use)
-
-The following section covers generating and exporting 3D models with Blend_My_NFTs with a repository of external 3D models in a folder structure. The 3D model generator combines 3D models together and exports all possible combinations of those 3D models to a folder.
-
-## How to set up your 3D model folders
-
-Similarly to the Image Generator, there is a specific way to format 3d model repositors external to Blender.
-
-1. In the following photo we have a folder structure. In this example, ``Sphere`` and ``Cube`` are our attributes. Any object file in the ``Script_Ignore_Folder`` will be added to all NFT 3D models generated, and such is an appropriate place to put constant scene elements you wish to appear in every NFT you generate.
-
-
-
-2. After you have formated the repository of 3D models to the above convention, copy and past it into the 3D_Model_Input folder located in Blend_My_NFTs:
-
-
-
-3. Next open config.py and change the variable ``use3DModels = False`` to ``use3DModels = True``
-
-
-
-4. In Blender open a new blend file and delete everything from the scene.
-
-5. Save the .blend file to the Blend_My_NFTs folder and reload the .blend file from the new directory.
-
-7. Run main.py in the Blender Scripting Tab
-
-The generated 3D models will appear in the folder 3D_Model_Output
-
-## How to use Rarity
-
-Rarity is a percentage value and accepts fractions like 0.001%, but they must be specified with decimals in the naming (fraction like 1/2 or 3/5 are not permitted in the naming structure). For ease of use the percentages should add up to 100%:
-
-```
-33% + 33% + 33% + 1% = 100%
-
-Variant 1 = 33% chance
-Variant 2 = 33% chance
-Variant 3 = 33% chance
-Variant 4 = 1% chance
-```
-
-If you have 20 variants with 50 set as the rarity percentage for each, Blend_My_NFTs will add up the percentages then treat the sum as 100%:
-
-```
-50% + 50% + 50% + 50% + 50%....
-= 1,000%
-
-Out of 100%:
-
-(50/1,000)*100 = 5% chance of 1 variant
-```
-
-Rarity is dependent on both the number of NFTs you generate, as well as the maximum number of possible combinations of the attributes in your .blend file.
-
-This means the following two scenarios, say, at a fixed number of 10,000 NFTs to generate;
-
-1. Your .blend file has 1,000,000,000 possible combinations (trust me that's a small number, our collection for This Cozy Place has over 11 Trillion possible combinations). Generating 10,000 will be more representative of the rarity numbers you set as the script will simply have more combinations to choose from.
-
-2. Your .blend file has 10,000 possible combinations. This means that all possible combinations of your NFT will be generated, meaning that no rarity can be taken into account since the only way to reach your required 10,000 NFTs to generate is by including NFTs that
-
-This is the result for following reasons:
-
-1. The rarity is determined sudo randomly by, but is weighted based on each variants rarity percentage.
-
-2. The script prioritises the number of NFTs to generate (that you set in config.py with the maxNFTs variable) over rarity percentage
-
-This behaviour is a fundamental mathematical result, not an issue with the code. I've researched various ways at creating and enforcing rarity, this is the only way I have found that works. If you have found a better method, feel free to make a pull request and I'd be happy to review and merge it to the main Github repo for BMNFTs.
-
-.blend file examples:
-
-1. With Rarity percentage (50% 50% split)
-```
- Hat <-- Attribute
- |-Green Hat_1_50
- |-Red Hat_2_50
-```
-
-2. Since it's 50/50 it can also be expressed like this:
-```
- Hat <-- Attribute
- |-Green Hat_1_0
- |-Red Hat_2_0
-```
-
-Leaving the rarity number as 0 will randomly select 1 of the variants you set in your .blend file. Note that this only works if every variant's rarity is set to 0. For an attribute its rarity or random, not both. You can have different attributes, where some are using rarity and others are randomly selected, but you cannot mix these with variants.
-
-Example of more complex rarity structures:
-
-```
- Hat <-- Attribute
- |-Green Hat_1_24.75
- |-Red Hat_2_24.75
- |-Blue Hat_2_24.75
- |-Orange Hat_2_24.57
- |-Purple Hat_2_0.5
- |-Yellow Hat_2_0.5
-```
-
-In the example above, Green, Red, Blue, and Orange hats all have an equal chance of getting selected. However Purple and Yellow hats will only appear on average 0.5% of the time. We recommend rounding to about 5 decimal places for simplicity, as numbers of more accuracy aren't really needed for NFT collections 10,000 or smaller.
-
-The code for that determines rarity can be found in ``src/Main_Generators/Rarity_Sorter.py``. The most important line in that file is ``70``, that is what generates the randomly weighted DNA. After that it is checked by line
-
-## Helpful Links
-
-This Blender add on heaviliy relies on the Blender API and its documentation which you can find here: https://docs.blender.org/api/current/index.html
-
-If you have no experience with the Blender API I recomend watch this tutorial on running python scripts in Blender: https://www.youtube.com/watch?v=cyt0O7saU4Q
-
-There is also helpful documentation in the Blender API about running scripts here: https://docs.blender.org/api/current/info_quickstart.html#running-scripts
-
-Note - You might want to install the Icon Viewer add-on for Blender: https://docs.blender.org/manual/en/latest/addons/development/icon_viewer.html
-
-## Disclaimers
-
-Blend_My_NFTs works with Windows 10 or macOS BigSure 11.6 on Blender 3.0.0. These are the operating systems I have tested the scripts on, I do not garuntee they will work on other operating systems. I do not garuntee this software will work with your setup. There are many variables and factors that go into running the software provided, it differs from system to system, and from blend file to blend file.
-
-I encourage you to do some trouble shooting, read the Blender API documentation, read this tutorial, review the scripts, and do your own research before reaching out for help on our discord. If you are really stuck and are out of options I am available on our disord channel above for consulting. However! I am not a toutor. Although I enjoy teaching people, I simply do not have the time to work, build this project, teach people Blender/Python, and live my life. So please respect my time, I'd love to help!
-
-To be honest I have no idea how to use Blender. I know some basic things, but I know the API and Python a lot better. This is my first Blender/Python project, so you may be wondering "how is he making a NFT collection with Blender??" Well I'm not, I write the code for the Blend_My_NFTs, and my team has three other members; Devlin and Caelin, who create the scenes and models in Blender, and the third is Quinn who is the lead web developer for our site.
-
-If building an NFT collection in blender is something you really want to do and you have experience with Blender, I suggest you get familiar with some basic Python functionality and then how to run scripts in the Belnder Text Editor (an indepth knowledge is not required). However, if you don't use Blender but have a coding background, I would suggest watching some basic tutorials just to get a feel for the software (an indepth knowledge is not required).
-
-This tutorial page is not finished! This page will be updated as I commit/merge new changes to the main branch. (Last updated Nov 10th, 2021)
-
-I garuntee this will eventually be an add on to Blender and not just a script you run through the script editor. (I mostly just put this in here for personal motivation, please don't pester me about the date lol)
-
-Nothing in this repository or its documentation is financial advice. If you create an NFT project or collection with Blend_My_NFTs, you do so at your own personal and financial risk. We are only providing a means of acomplishing a goal, not investment or financial information about that goal. Do your own research and come to your own conclusions before spending money on NFTs or any asset for that matter. We are not liable for any finacial losses you may encure while using this software. Any discussion about finances and cryptocurrencies in this repository or its documentation are done with the intent to educate and provide examples to help our users understand concepts relating to Blend_My_NFTs and This Cozy Place.
-
-The creators of This Cozy Studio will never, under any cricumstance, ask for your crypto wallet(s) secret phrase or private keys. If you come across anyone who is impersonating the founding members of This Cozy Place, please report it immediately to the admins on our discord channel and we will take appropriate action and warn our community of the behaviour. If this takes place outside of our community boundries then report the user to the appropriate authorities.
-
-This software is provided for free and is open source. We are not liable for any felones you may commit using this software, and we staunchly appose the malicious use of this software that in any way breaks any applicable law in your loction of residence.
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000..f9ac261
--- /dev/null
+++ b/__init__.py
@@ -0,0 +1,275 @@
+bl_info = {
+ "name": "Blend_My_NFTs",
+ "author": "Torrin Leonard, This Cozy Studio Inc",
+ "version": (1, 0, 0),
+ "blender": (3, 0, 0),
+ "location": "View3D",
+ "description": "Blend_My_NFTs UI Edition",
+ "category": "Development",
+}
+
+# Import handling:
+
+import bpy
+import os
+import importlib
+
+from .main import DNA_Generator, Batch_Sorter, Exporter, Batch_Refactorer
+
+importlib.reload(DNA_Generator)
+importlib.reload(Batch_Sorter)
+importlib.reload(Exporter)
+importlib.reload(Batch_Refactorer)
+
+
+# User input Property Group:
+
+class BMNFTS_PGT_MyProperties(bpy.types.PropertyGroup):
+ # Main BMNFTS Panel properties:
+
+ nftName: bpy.props.StringProperty(name="NFT Name")
+
+ collectionSize: bpy.props.IntProperty(name="NFT Collection Size") # config.py = maxNFTs
+ nftsPerBatch: bpy.props.IntProperty(name="NFTs Per Batch") # config.py = nftsPerBatch
+ batchToGenerate: bpy.props.IntProperty(name="Batch To Generate", default=1) # config.py = renderBatch
+
+ save_path: bpy.props.StringProperty(name="Save Path",
+ description="Save path for NFT files",
+ default="",
+ maxlen=1024,
+ subtype="DIR_PATH")
+
+ enableRarity: bpy.props.BoolProperty(name="Enable Rarity")
+
+ imageBool: bpy.props.BoolProperty(name="Image")
+ imageEnum: bpy.props.EnumProperty(
+ name="Image File Format",
+ description="Select Image file format",
+ items=[
+ ('PNG', ".PNG", "Export NFT as PNG"),
+ ('JPEG', ".JPEG", "Export NFT as JPEG")
+ ]
+ )
+
+ animationBool: bpy.props.BoolProperty(name="Animation")
+ animationEnum: bpy.props.EnumProperty(
+ name="Animation File Format",
+ description="Select Animation file format",
+ items=[
+ ('AVI_JPEG', "AVI_JPEG", "Export NFT as AVI_JPEG"),
+ ('AVI_RAW', "AVI_RAW", "Export NFT as AVI_RAW"),
+ ('FFMPEG', "FFMPEG", "Export NFT as FFMPEG")
+ ]
+ )
+
+ modelBool: bpy.props.BoolProperty(name="3D Model")
+ modelEnum: bpy.props.EnumProperty(
+ name="3D Model File Format",
+ description="Select 3D Model file format",
+ items=[
+ ('GLB', '.glb', 'Export NFT as .glb'),
+ ('GLTF_SEPARATE', '.gltf + .bin + textures', 'Export NFT as .gltf with separated textures in .bin + textures.'),
+ ('GLTF_EMBEDDED', '.gltf', 'Export NFT as embedded .gltf file that contains textures.'),
+ ('FBX', '.fbx', 'Export NFT as .fbx'),
+ ('OBJ', '.obj', 'Export NFT as .obj'),
+ ('X3D', '.x3d', 'Export NFT as .x3d'),
+ ('VOX', '.vox', 'Export NFT as .vox, requires the voxwriter add on: https://github.com/Spyduck/voxwriter')
+ ]
+ )
+
+ number: bpy.props.FloatProperty(name="float")
+
+ cardanoMetaDataBool: bpy.props.BoolProperty(name="Cardano Cip")
+ solanaMetaDataBool: bpy.props.BoolProperty(name="Solana Metaplex")
+ erc721MetaData: bpy.props.BoolProperty(name="ERC721")
+
+ # API Panel properties:
+ apiKey: bpy.props.StringProperty(name="API Key", subtype='PASSWORD')
+
+
+def make_directories(save_path):
+ Blend_My_NFTs_Output = os.path.join(save_path, "Blend_My_NFTs Output", "NFT_Data")
+ batch_json_save_path = os.path.join(Blend_My_NFTs_Output, "Batch_Data")
+
+ nftBatch_save_path = os.path.join(save_path, "Blend_My_NFTs Output", "Generated NFT Batches")
+
+ if not os.path.exists(Blend_My_NFTs_Output):
+ os.makedirs(Blend_My_NFTs_Output)
+ if not os.path.exists(batch_json_save_path):
+ os.makedirs(batch_json_save_path)
+ if not os.path.exists(nftBatch_save_path):
+ os.makedirs(nftBatch_save_path)
+ return Blend_My_NFTs_Output, batch_json_save_path, nftBatch_save_path
+
+class createData(bpy.types.Operator):
+ bl_idname = 'create.data'
+ bl_label = 'Create Data'
+ bl_description = 'Creates NFT Data. Run after any changes were made to scene.'
+ bl_options = {"REGISTER", "UNDO"}
+
+ def execute(self, context):
+
+ nftName = bpy.context.scene.my_tool.nftName
+ maxNFTs = bpy.context.scene.my_tool.collectionSize
+ nftsPerBatch = bpy.context.scene.my_tool.nftsPerBatch
+ save_path = bpy.context.scene.my_tool.save_path
+ enableRarity = bpy.context.scene.my_tool.enableRarity
+
+ Blend_My_NFTs_Output, batch_json_save_path, nftBatch_save_path = make_directories(save_path)
+
+ DNA_Generator.send_To_Record_JSON(nftName, maxNFTs, nftsPerBatch, save_path, enableRarity, Blend_My_NFTs_Output)
+ Batch_Sorter.makeBatches(nftName, maxNFTs, nftsPerBatch, save_path, batch_json_save_path)
+ return {"FINISHED"}
+
+class exportNFTs(bpy.types.Operator):
+ bl_idname = 'exporter.nfts'
+ bl_label = 'Export NFTs'
+ bl_description = 'Generate and export a given batch of NFTs.'
+ bl_options = {"REGISTER", "UNDO"}
+
+ def execute(self, context):
+ nftName = bpy.context.scene.my_tool.nftName
+ save_path = bpy.context.scene.my_tool.save_path
+ batchToGenerate = bpy.context.scene.my_tool.batchToGenerate
+ maxNFTs = bpy.context.scene.my_tool.collectionSize
+
+ Blend_My_NFTs_Output, batch_json_save_path, nftBatch_save_path = make_directories(save_path)
+
+ enableImages = bpy.context.scene.my_tool.imageBool
+ print(enableImages)
+ imageFileFormat = bpy.context.scene.my_tool.imageEnum
+ print(imageFileFormat)
+
+ enableAnimations = bpy.context.scene.my_tool.animationBool
+ animationFileFormat = bpy.context.scene.my_tool.animationEnum
+
+ enableModelsBlender = bpy.context.scene.my_tool.modelBool
+ modelFileFormat = bpy.context.scene.my_tool.modelEnum
+
+
+ Exporter.render_and_save_NFTs(nftName, maxNFTs, batchToGenerate, batch_json_save_path, nftBatch_save_path, enableImages,
+ imageFileFormat, enableAnimations, animationFileFormat, enableModelsBlender,
+ modelFileFormat
+ )
+ return {"FINISHED"}
+
+class refactor_Batches(bpy.types.Operator):
+ bl_idname = 'refactor.batches'
+ bl_label = 'Refactor Batches'
+ bl_description = 'Generate and export a given batch of NFTs.'
+ bl_options = {"REGISTER", "UNDO"}
+
+ def execute(self, context):
+ save_path = bpy.context.scene.my_tool.save_path
+
+ cardanoMetaDataBool = bpy.context.scene.my_tool.cardanoMetaDataBool
+ solanaMetaDataBool = bpy.context.scene.my_tool.solanaMetaDataBool
+ erc721MetaData = bpy.context.scene.my_tool.erc721MetaData
+
+ Blend_My_NFTs_Output, batch_json_save_path, nftBatch_save_path = make_directories(save_path)
+
+ Batch_Refactorer.reformatNFTCollection(save_path, Blend_My_NFTs_Output, batch_json_save_path, nftBatch_save_path,
+ cardanoMetaDataBool, solanaMetaDataBool, erc721MetaData)
+
+
+
+# Main Panel:
+class BMNFTS_PT_MainPanel(bpy.types.Panel):
+ bl_label = "Blend_My_NFTs"
+ bl_idname = "BMNFTS_PT_MainPanel"
+ bl_space_type = 'VIEW_3D'
+ bl_region_type = 'UI'
+ bl_category = 'Blend_My_NFTs'
+
+ def draw(self, context):
+ layout = self.layout
+ scene = context.scene
+ mytool = scene.my_tool
+
+ row = layout.row()
+ row.prop(mytool, "nftName")
+
+ row = layout.row()
+ row.prop(mytool, "collectionSize")
+
+ row = layout.row()
+ row.prop(mytool, "nftsPerBatch")
+
+ row = layout.row()
+ row.prop(mytool, "batchToGenerate")
+
+ row = layout.row()
+ layout.label(text="Export NFT as:")
+
+ row = layout.row()
+ row.prop(mytool, "imageBool")
+ if bpy.context.scene.my_tool.imageBool == True:
+ row.prop(mytool, "imageEnum")
+
+ row = layout.row()
+ row.prop(mytool, "animationBool")
+ if bpy.context.scene.my_tool.animationBool == True:
+ row.prop(mytool, "animationEnum")
+
+ row = layout.row()
+ row.prop(mytool, "modelBool")
+ if bpy.context.scene.my_tool.modelBool == True:
+ row.prop(mytool, "modelEnum")
+
+ row = layout.row()
+ row.prop(mytool, "save_path")
+
+ row = layout.row()
+ row.prop(mytool, "enableRarity")
+
+ row = layout.row()
+ self.layout.operator("create.data", icon='MESH_CUBE', text="Create Data")
+
+ row = layout.row()
+ self.layout.operator("exporter.nfts", icon='MESH_CUBE', text="Generate NFTs")
+
+ row = layout.row()
+ layout.label(text="Meta Data format:")
+
+ row = layout.row()
+ row.prop(mytool, "cardanoMetaDataBool")
+ row.prop(mytool, "solanaMetaDataBool")
+ row.prop(mytool, "erc721MetaData")
+ self.layout.operator("refactor.batches", icon='MESH_CUBE', text="Refactor Batches & create MetaData")
+
+
+# API Panel:
+class BMNFTS_PT_API_Panel(bpy.types.Panel):
+ bl_label = "API"
+ bl_idname = "BMNFTS_PT_API_Panel"
+ bl_space_type = 'VIEW_3D'
+ bl_region_type = 'UI'
+ bl_category = 'Blend_My_NFTs'
+
+ def draw(self, context):
+ layout = self.layout
+ scene = context.scene
+ mytool = scene.my_tool
+
+ row = layout.row()
+ row.prop(mytool, "apiKey")
+
+
+# Register and Unregister classes from Blender:
+classes = (BMNFTS_PGT_MyProperties, BMNFTS_PT_MainPanel, BMNFTS_PT_API_Panel, createData, exportNFTs, refactor_Batches)
+
+def register():
+ for cls in classes:
+ bpy.utils.register_class(cls)
+
+ bpy.types.Scene.my_tool = bpy.props.PointerProperty(type=BMNFTS_PGT_MyProperties)
+
+def unregister():
+ for cls in classes:
+ bpy.utils.unregister_class(cls)
+
+ del bpy.types.Scene.my_tool
+
+
+if __name__ == '__main__':
+ register()
diff --git a/src/Utility_Scripts/BatchRefactorer.py b/main/Batch_Refactorer.py
similarity index 76%
rename from src/Utility_Scripts/BatchRefactorer.py
rename to main/Batch_Refactorer.py
index a03e2dd..ded7fe4 100644
--- a/src/Utility_Scripts/BatchRefactorer.py
+++ b/main/Batch_Refactorer.py
@@ -3,32 +3,25 @@
import bpy
import os
-import sys
import copy
import json
import importlib
-dir = os.path.dirname(bpy.data.filepath)
-sys.path.append(dir)
-sys.modules.values()
+from . import metaData
-from src import config
-from src.Main_Generators import metaData
-
-importlib.reload(config)
importlib.reload(metaData)
removeList = [".gitignore", ".DS_Store"]
-def getNFType():
+def getNFType(nftBatch_save_path):
images = False
animations = False
models = False
metaData = False
- batch1 = [x for x in os.listdir(config.nft_save_path) if (x not in removeList)][0] # Gets first Batch and ignores removeList files
- batchContent = os.listdir(os.path.join(config.nft_save_path, batch1))
+ batch1 = [x for x in os.listdir(nftBatch_save_path) if (x not in removeList)][0] # Gets first Batch and ignores removeList files
+ batchContent = os.listdir(os.path.join(nftBatch_save_path, batch1))
batchContent = [x for x in batchContent if (x not in removeList)]
if "Images" in batchContent:
@@ -51,69 +44,69 @@ def getMetaDataDirty(completeMetaDataPath, i):
metaDataDirty = json.load(open(file_name))
name = metaDataDirty["name"]
- description = metaDataDirty["description"]
NFT_DNA = metaDataDirty["NFT_DNA"]
NFT_Variants = metaDataDirty["NFT_Variants"]
- if config.turnNumsOff:
- for i in NFT_Variants:
- x = NFT_Variants[i]
- NFT_Variants[i] = x.split("_")[0]
+ for i in NFT_Variants:
+ x = NFT_Variants[i]
+ NFT_Variants[i] = x.split("_")[0]
- return name, description, NFT_DNA, NFT_Variants
+ return name, NFT_DNA, NFT_Variants
def sendMetaDataToJson(metaDataDict, metaDataPath, jsonName):
jsonMetaData = json.dumps(metaDataDict, indent=1, ensure_ascii=True)
with open(os.path.join(metaDataPath, jsonName), 'w') as outfile:
outfile.write(jsonMetaData + '\n')
-def renameMetaData(completeCollPath, completeMetaDataPath):
+def renameMetaData(completeCollPath, completeMetaDataPath, cardanoMetaDataBool, solanaMetaDataBool, erc721MetaData):
metaDataListOld = os.listdir(completeMetaDataPath)
cardanoMetaDataPath = os.path.join(completeCollPath, "Cardano_metaData")
solanaMetaDataPath = os.path.join(completeCollPath, "Solana_metaData")
erc721MetaDataPath = os.path.join(completeCollPath, "Erc721_metaData")
for i in metaDataListOld:
- name, description, NFT_DNA, NFT_Variants = getMetaDataDirty(completeMetaDataPath, i)
+ name, NFT_DNA, NFT_Variants = getMetaDataDirty(completeMetaDataPath, i)
file_name = os.path.splitext(i)[0]
file_num = file_name.split("_")[1]
- if config.cardanoMetaData:
+ if cardanoMetaDataBool:
if not os.path.exists(cardanoMetaDataPath):
os.mkdir(cardanoMetaDataPath)
cardanoJsonNew = "Cardano_" + i
cardanoNewName = name.split("_")[0] + "_" + str(file_num)
- metaDataDictCardano = metaData.returnCardanoMetaData(cardanoNewName, description, NFT_DNA, NFT_Variants)
+ metaDataDictCardano = metaData.returnCardanoMetaData(cardanoNewName, NFT_DNA, NFT_Variants)
sendMetaDataToJson(metaDataDictCardano, cardanoMetaDataPath, cardanoJsonNew)
- if config.solanaMetaData:
+ if solanaMetaDataBool:
if not os.path.exists(solanaMetaDataPath):
os.mkdir(solanaMetaDataPath)
solanaJsonNew = "Solana_" + i
solanaNewName = name.split("_")[0] + "_" + str(file_num)
- metaDataDictSolana = metaData.returnSolanaMetaData(solanaNewName, description, NFT_DNA, NFT_Variants)
+ metaDataDictSolana = metaData.returnSolanaMetaData(solanaNewName, NFT_DNA, NFT_Variants)
sendMetaDataToJson(metaDataDictSolana, solanaMetaDataPath, solanaJsonNew)
- if config.erc721MetaData:
+ if erc721MetaData:
if not os.path.exists(erc721MetaDataPath):
os.mkdir(erc721MetaDataPath)
erc721JsonNew = "Erc721_" + i
erc721NewName = name.split("_")[0] + "_" + str(file_num)
- metaDataDictErc721 = metaData.returnErc721MetaData(erc721NewName, description, NFT_DNA, NFT_Variants)
+ metaDataDictErc721 = metaData.returnErc721MetaData(erc721NewName, NFT_DNA, NFT_Variants)
sendMetaDataToJson(metaDataDictErc721, erc721MetaDataPath, erc721JsonNew)
return
-def reformatNFTCollection():
- images, animations, models, metaData = getNFType()
+def reformatNFTCollection(save_path, Blend_My_NFTs_Output, batch_json_save_path, nftBatch_save_path, cardanoMetaDataBool,
+ solanaMetaDataBool, erc721MetaData):
- completeCollPath = os.path.join(config.save_path, "Complete_Collection")
+ images, animations, models, metaData = getNFType(nftBatch_save_path)
+
+ completeCollPath = os.path.join(save_path, "Complete_Collection")
completeImagePath = os.path.join(completeCollPath, "Images")
completeAnimationsPath = os.path.join(completeCollPath, "Animations")
completeModelsPath = os.path.join(completeCollPath, "Models")
@@ -130,7 +123,7 @@ def reformatNFTCollection():
if metaData and not os.path.exists(completeMetaDataPath):
os.mkdir(completeMetaDataPath)
- batchListDirty = os.listdir(config.nft_save_path)
+ batchListDirty = os.listdir(nftBatch_save_path)
batchList = [x for x in batchListDirty if (x not in removeList)]
imageCount = 1
@@ -139,11 +132,11 @@ def reformatNFTCollection():
dataCount = 1
for i in batchList:
if images:
- imagesDir = os.path.join(config.nft_save_path, i, "Images")
+ imagesDir = os.path.join(nftBatch_save_path, i, "Images")
imagesList = sorted(os.listdir(imagesDir))
for j in imagesList:
- imageOldPath = os.path.join(config.nft_save_path, i, "Images", j)
+ imageOldPath = os.path.join(nftBatch_save_path, i, "Images", j)
nameOldDirty = copy.deepcopy(os.path.splitext(j)[0])
extension = copy.deepcopy(os.path.splitext(j)[1])
nameOldClean = nameOldDirty.split("_")[0]
@@ -156,11 +149,11 @@ def reformatNFTCollection():
imageCount += 1
if animations:
- animationsDir = os.path.join(config.nft_save_path, i, "Animations")
+ animationsDir = os.path.join(nftBatch_save_path, i, "Animations")
animationsList = sorted(os.listdir(animationsDir))
for j in animationsList:
- animationOldPath = os.path.join(config.nft_save_path, i, "Animations", j)
+ animationOldPath = os.path.join(nftBatch_save_path, i, "Animations", j)
nameOldDirty = copy.deepcopy(os.path.splitext(j)[0])
extension = copy.deepcopy(os.path.splitext(j)[1])
nameOldClean = nameOldDirty.split("_")[0]
@@ -173,11 +166,11 @@ def reformatNFTCollection():
animationCount += 1
if models:
- modelsDir = os.path.join(config.nft_save_path, i, "Models")
+ modelsDir = os.path.join(nftBatch_save_path, i, "Models")
modelsList = sorted(os.listdir(modelsDir))
for j in modelsList:
- modelOldPath = os.path.join(config.nft_save_path, i, "Models", j)
+ modelOldPath = os.path.join(nftBatch_save_path, i, "Models", j)
nameOldDirty = copy.deepcopy(os.path.splitext(j)[0])
extension = copy.deepcopy(os.path.splitext(j)[1])
nameOldClean = nameOldDirty.split("_")[0]
@@ -190,11 +183,11 @@ def reformatNFTCollection():
modelCount += 1
if metaData:
- dataDir = os.path.join(config.nft_save_path, i, "BMNFT_metaData")
+ dataDir = os.path.join(nftBatch_save_path, i, "BMNFT_metaData")
dataList = sorted(os.listdir(dataDir))
for j in dataList:
- dataOldPath = os.path.join(config.nft_save_path, i, "BMNFT_metaData", j)
+ dataOldPath = os.path.join(nftBatch_save_path, i, "BMNFT_metaData", j)
nameOldDirty = copy.deepcopy(os.path.splitext(j)[0])
extension = copy.deepcopy(os.path.splitext(j)[1])
nameOldClean = nameOldDirty.split("_")[0]
@@ -213,9 +206,9 @@ def reformatNFTCollection():
dataCount += 1
- print(f"All NFT files stored and sorted to the Complete_Collection folder in {config.save_path}")
+ print(f"All NFT files stored and sorted to the Complete_Collection folder in {save_path}")
- renameMetaData(completeCollPath, completeMetaDataPath)
+ renameMetaData(completeCollPath, completeMetaDataPath, cardanoMetaDataBool, solanaMetaDataBool, erc721MetaData)
if __name__ == '__main__':
diff --git a/src/Main_Generators/Batch_Sorter.py b/main/Batch_Sorter.py
similarity index 58%
rename from src/Main_Generators/Batch_Sorter.py
rename to main/Batch_Sorter.py
index 328ca86..c3f07dc 100644
--- a/src/Main_Generators/Batch_Sorter.py
+++ b/main/Batch_Sorter.py
@@ -9,41 +9,40 @@ import json
import random
import importlib
-dir = os.path.dirname(bpy.data.filepath)
-sys.path.append(dir)
-sys.modules.values()
-from src import config
+def makeBatches(nftName, maxNFTs, nftsPerBatch, save_path, batch_json_save_path):
+ Blend_My_NFTs_Output = os.path.join(save_path, "Blend_My_NFTs Output", "NFT_Data")
+ NFTRecord_save_path = os.path.join(Blend_My_NFTs_Output, "NFTRecord.json")
-importlib.reload(config)
-
-if config.runPreview:
- config.nftsPerBatch = config.maxNFTsTest
- config.maxNFTs = config.maxNFTsTest
- config.renderBatch = 1
- config.nftName = "TestImages"
-
-
-def makeBatches():
- file_name = os.path.join(config.save_path, "NFTRecord.json")
- DataDictionary = json.load(open(file_name))
+ DataDictionary = json.load(open(NFTRecord_save_path))
numNFTsGenerated = DataDictionary["numNFTsGenerated"]
hierarchy = DataDictionary["hierarchy"]
DNAList = DataDictionary["DNAList"]
- numBatches = config.maxNFTs / config.nftsPerBatch
+ numBatches = maxNFTs / nftsPerBatch
- print(f"To generate batches of {config.nftsPerBatch} DNA sequences per batch, with a total of {numNFTsGenerated}"
+ print(f"To generate batches of {nftsPerBatch} DNA sequences per batch, with a total of {numNFTsGenerated}"
f" possible NFT DNA sequences, the number of batches generated will be {numBatches}")
+ # Clears the Batch Data folder of Batches:
+ batchList = os.listdir(batch_json_save_path)
+
+ if batchList:
+ for i in batchList:
+ batch = os.path.join(batch_json_save_path, i)
+ if os.path.exists(batch):
+ os.remove(
+ os.path.join(batch_json_save_path, i)
+ )
+
i = 0
while i < numBatches:
batchDictionary = {}
BatchDNAList = []
j = 0
- while (j < config.nftsPerBatch) and (DNAList):
+ while (j < nftsPerBatch) and (DNAList):
oneDNA = random.choice(DNAList)
BatchDNAList.append(oneDNA)
DNAList.remove(oneDNA)
@@ -55,7 +54,7 @@ def makeBatches():
batchDictionaryObject = json.dumps(batchDictionary, indent=1, ensure_ascii=True)
- with open(os.path.join(config.batch_json_save_path, ("Batch{}.json".format(i + 1))), "w") as outfile:
+ with open(os.path.join(batch_json_save_path, ("Batch{}.json".format(i + 1))), "w") as outfile:
outfile.write(batchDictionaryObject)
i += 1
@@ -67,7 +66,7 @@ def makeBatches():
incompleteBatch = json.dumps(incompleteBatch, indent=1, ensure_ascii=True)
- with open(os.path.join(config.batch_json_save_path, ("Batch{}.json".format(i + 1))), "w") as outfile2:
+ with open(os.path.join(batch_json_save_path, ("Batch{}.json".format(i + 1))), "w") as outfile2:
outfile2.write(incompleteBatch)
diff --git a/src/Main_Generators/DNA_Generator.py b/main/DNA_Generator.py
similarity index 84%
rename from src/Main_Generators/DNA_Generator.py
rename to main/DNA_Generator.py
index f5f2af0..155a0d7 100644
--- a/src/Main_Generators/DNA_Generator.py
+++ b/main/DNA_Generator.py
@@ -4,7 +4,6 @@
import bpy
import os
import re
-import sys
import copy
import time
import json
@@ -12,22 +11,11 @@ import random
import importlib
from functools import partial
-dir = os.path.dirname(bpy.data.filepath)
-sys.path.append(dir)
-sys.modules.values()
-
-from src import config
-from src.Main_Generators import Rarity_Sorter
-
-importlib.reload(config)
+from . import Rarity_Sorter
importlib.reload(Rarity_Sorter)
-
-if config.runPreview:
- config.nftsPerBatch = config.maxNFTsTest
- config.maxNFTs = config.maxNFTsTest
- config.renderBatch = 1
- config.nftName = "TestImages"
+enableGeneration = False
+colorList = []
class bcolors:
'''
@@ -38,14 +26,13 @@ class bcolors:
ERROR = '\033[91m' # RED
RESET = '\033[0m' # RESET COLOR
-time_start = time.time()
-print("")
+time_start = time.time()
def stripColorFromName(name):
return "_".join(name.split("_")[:-1])
-def returnData():
+def returnData(nftName, maxNFTs, nftsPerBatch, save_path, enableRarity):
'''
Generates important variables, dictionaries, and lists needed to be stored to catalog the NFTs.
:return: listAllCollections, attributeCollections, attributeCollections1, hierarchy, variantMetaData, possibleCombinations
@@ -84,9 +71,9 @@ def returnData():
ignoreList = listSubIgnoreCollections()
for i in listAllCollInScene:
- if config.enableGeneration:
- if i.name in config.colorList:
- for j in range(len(config.colorList[i.name])):
+ if enableGeneration:
+ if i.name in colorList:
+ for j in range(len(colorList[i.name])):
if i.name[-1].isdigit() and i.name not in ignoreList:
listAllCollections.append(i.name + "_" + str(j + 1))
elif j == 0:
@@ -173,7 +160,7 @@ def returnData():
elif len(orderRarity) > 0:
number = orderRarity[0]
- if config.enableGeneration:
+ if enableGeneration:
if count == 1 or count == 0:
previousAttribute = i.partition("_")[0]
count +=1
@@ -183,7 +170,7 @@ def returnData():
count = 1
number = str(count)
rarity = orderRarity[1]
- if config.enableGeneration and stripColorFromName(i) in config.colorList:
+ if enableGeneration and stripColorFromName(i) in colorList:
color = orderRarity[2]
else:
color = "0"
@@ -202,12 +189,12 @@ def returnData():
colParLong = list(bpy.data.collections[str(i)].children)
colParShort = {}
for x in colParLong:
- if config.enableGeneration:
+ if enableGeneration:
"""
Append colors to blender name for PNG generator and NFTRecord.json to create the correct list
"""
- if x.name in config.colorList:
- for j in range(len(config.colorList[x.name])):
+ if x.name in colorList:
+ for j in range(len(colorList[x.name])):
colParShort[x.name + "_" + str(j+1)] = None
else:
colParShort[x.name + "_0"] = None
@@ -244,7 +231,7 @@ def returnData():
combinations = combinations*i
try:
- numBatches = combinations/config.nftsPerBatch
+ numBatches = combinations/nftsPerBatch
except:
print(f"{bcolors.ERROR} ERROR:\nnftsPerBatch in config.py needs to be a positive integer. {bcolors.RESET}")
@@ -259,7 +246,7 @@ def returnData():
if numBatches < 1:
print(f"{bcolors.ERROR} ERROR: {bcolors.RESET}")
print("The number of NFTs Per Batch (nftsPerBatch variable in config.py) is to high. There are a total of "
- f" {combinations} possible NFT combinations and you've requested {config.nftsPerBatch} NFTs per batch. "
+ f" {combinations} possible NFT combinations and you've requested {nftsPerBatch} NFTs per batch. "
f"Lower the number of NFTs per batch in config.py or increase the number of attributes and/or variants in your .blend file.")
return combinations
@@ -268,7 +255,7 @@ def returnData():
for i in variantMetaData:
def cameraToggle(i, toggle=True):
- if config.enableGeneration:
+ if enableGeneration:
"""
Remove Color code so blender recognises the collection
"""
@@ -279,21 +266,21 @@ def returnData():
return listAllCollections, attributeCollections, attributeCollections1, hierarchy, possibleCombinations
-def generateNFT_DNA():
+def generateNFT_DNA(nftName, maxNFTs, nftsPerBatch, save_path, enableRarity):
"""
Returns batchDataDictionary containing the number of NFT combinations, hierarchy, and the DNAList.
"""
- listAllCollections, attributeCollections, attributeCollections1, hierarchy, possibleCombinations = returnData()
+ listAllCollections, attributeCollections, attributeCollections1, hierarchy, possibleCombinations = returnData(nftName, maxNFTs, nftsPerBatch, save_path, enableRarity)
print(f"NFT Combinations: {possibleCombinations}\n")
- print(f"Generating {config.maxNFTs} combinations of DNA.\n")
+ print(f"Generating {maxNFTs} combinations of DNA.\n")
DataDictionary = {}
listOptionVariant = []
DNAList = []
- if not config.enableRarity:
+ if not enableRarity:
DNASet = set()
for i in hierarchy:
@@ -318,27 +305,27 @@ def generateNFT_DNA():
return str(dna)
- for i in range(config.maxNFTs):
+ for i in range(maxNFTs):
dnaPushToList = partial(createDNARandom)
- DNASet |= {''.join([dnaPushToList()]) for _ in range(config.maxNFTs - len(DNASet))}
+ DNASet |= {''.join([dnaPushToList()]) for _ in range(maxNFTs - len(DNASet))}
DNAList = list(DNASet)
- possibleCombinations = config.maxNFTs
+ possibleCombinations = maxNFTs
- if config.nftsPerBatch > config.maxNFTs:
+ if nftsPerBatch > maxNFTs:
print(bcolors.WARNING + "\nWARNING:" + bcolors.RESET)
- print(f"The Max num of NFTs you chose is smaller than the NFTs Per Batch you set. Only {config.maxNFTs} were added to 1 batch")
+ print(f"The Max num of NFTs you chose is smaller than the NFTs Per Batch you set. Only {maxNFTs} were added to 1 batch")
- if config.enableRarity:
+ if enableRarity:
print(f"{bcolors.OK} Rarity is on. Weights listed in .blend will be taken into account {bcolors.RESET}")
- possibleCombinations = config.maxNFTs
- DNAList = Rarity_Sorter.sortRarityWeights(hierarchy, listOptionVariant, DNAList)
+ possibleCombinations = maxNFTs
+ DNAList = Rarity_Sorter.sortRarityWeights(hierarchy, listOptionVariant, DNAList, nftName, maxNFTs, nftsPerBatch, save_path, enableRarity)
- if len(DNAList) < config.maxNFTs:
+ if len(DNAList) < maxNFTs:
print(f"{bcolors.ERROR} \nWARNING: \n"
- f"You are seeing this warning because the program cannot generate {config.maxNFTs} NFTs with rarity enabled. "
+ f"You are seeing this warning because the program cannot generate {maxNFTs} NFTs with rarity enabled. "
f"Only {len(DNAList)} NFT DNA were generated."
f"Either A) Lower the number of NFTs you wish to create, or B) Increase the maximum number of possible NFTs by"
f" creating more variants and attributes in your .blend file.{bcolors.RESET}")
@@ -350,7 +337,7 @@ def generateNFT_DNA():
return DataDictionary, possibleCombinations, DNAList
-def send_To_Record_JSON():
+def send_To_Record_JSON(nftName, maxNFTs, nftsPerBatch, save_path, enableRarity, Blend_My_NFTs_Output):
"""
Creates NFTRecord.json file and sends "batchDataDictionary" to it. NFTRecord.json is a permanent record of all DNA
you've generated with all attribute variants. If you add new variants or attributes to your .blend file, other scripts
@@ -358,19 +345,20 @@ def send_To_Record_JSON():
repeate DNA.
"""
- DataDictionary, possibleCombinations, DNAList = generateNFT_DNA()
+ DataDictionary, possibleCombinations, DNAList = generateNFT_DNA(nftName, maxNFTs, nftsPerBatch, save_path, enableRarity)
+
+ NFTRecord_save_path = os.path.join(Blend_My_NFTs_Output, "NFTRecord.json")
try:
ledger = json.dumps(DataDictionary, indent=1, ensure_ascii=True)
- with open(os.path.join(config.save_path, "NFTRecord.json"), 'w') as outfile:
+ with open(NFTRecord_save_path, 'w') as outfile:
outfile.write(ledger + '\n')
- print(f"{bcolors.OK}{len(DNAList)} NFT DNA sent to NFTRecord.json in %.4f seconds.\n" % (time.time() - time_start) + bcolors.RESET)
+ print(f"{bcolors.OK}{len(DNAList)} NFT DNA saved to {NFTRecord_save_path}\n"
+ f"NFT DNA Successfully created. {bcolors.RESET}")
except:
- print(f"{bcolors.ERROR} ERROR:\nNFT DNA not sent to NFTRecord.json.\n {bcolors.RESET}")
+ print(f"{bcolors.ERROR} ERROR:\nNFT DNA not sent to {NFTRecord_save_path}\n {bcolors.RESET}")
if __name__ == '__main__':
- stripColorFromName()
- returnData()
send_To_Record_JSON()
diff --git a/src/Main_Generators/Exporter.py b/main/Exporter.py
similarity index 62%
rename from src/Main_Generators/Exporter.py
rename to main/Exporter.py
index 57492fe..128c551 100644
--- a/src/Main_Generators/Exporter.py
+++ b/main/Exporter.py
@@ -4,20 +4,13 @@
import bpy
import os
-import sys
import time
import json
-import importlib
-dir = os.path.dirname(bpy.data.filepath)
-sys.path.append(dir)
-sys.modules.values()
-from src import config
-from src.Main_Generators import metaData
-
-importlib.reload(config)
-importlib.reload(metaData)
+enableGeneration = False
+colorList = []
+generationType = None
class bcolors:
'''
@@ -29,21 +22,15 @@ class bcolors:
RESET = '\033[0m' # RESET COLOR
-if config.runPreview:
- config.nftsPerBatch = config.maxNFTsTest
- config.maxNFTs = config.maxNFTsTest
- config.renderBatch = 1
- config.nftName = "TestImages"
-
def stripColorFromName(name):
return "_".join(name.split("_")[:-1])
-def getBatchData():
+def getBatchData(batchToGenerate, batch_json_save_path):
"""
Retrieves a given batches data determined by renderBatch in config.py
"""
- file_name = os.path.join(config.batch_json_save_path, "Batch{}.json".format(config.renderBatch))
+ file_name = os.path.join(batch_json_save_path, "Batch{}.json".format(batchToGenerate))
batch = json.load(open(file_name))
NFTs_in_Batch = batch["NFTs_in_Batch"]
@@ -52,13 +39,16 @@ def getBatchData():
return NFTs_in_Batch, hierarchy, BatchDNAList
-def render_and_save_NFTs():
+def render_and_save_NFTs(nftName, maxNFTs, batchToGenerate, batch_json_save_path, nftBatch_save_path, enableImages,
+ imageFileFormat, enableAnimations, animationFileFormat, enableModelsBlender,
+ modelFileFormat
+ ):
"""
Renders the NFT DNA in a Batch#.json, where # is renderBatch in config.py. Turns off the viewport camera and
the render camera for all items in hierarchy.
"""
- NFTs_in_Batch, hierarchy, BatchDNAList = getBatchData()
+ NFTs_in_Batch, hierarchy, BatchDNAList = getBatchData(batchToGenerate, batch_json_save_path)
time_start_1 = time.time()
@@ -66,7 +56,7 @@ def render_and_save_NFTs():
for a in BatchDNAList:
for i in hierarchy:
for j in hierarchy[i]:
- if config.enableGeneration:
+ if enableGeneration:
"""
Remove Color code so blender recognises the collection
"""
@@ -94,20 +84,20 @@ def render_and_save_NFTs():
return dnaDictionary
dnaDictionary = match_DNA_to_Variant(a)
- name = config.nftName + "_" + str(x)
+ name = nftName + "_" + str(x)
- print(f"\n{bcolors.OK}|---Generating {x} NFT Files---|{bcolors.RESET}")
+ print(f"\n{bcolors.OK}|---Generating NFT {x}/{NFTs_in_Batch} ---|{bcolors.RESET}")
print(f"DNA attribute list:\n{dnaDictionary}\nDNA Code:{a}")
for c in dnaDictionary:
collection = dnaDictionary[c]
- if not config.enableGeneration:
+ if not enableGeneration:
bpy.data.collections[collection].hide_render = False
bpy.data.collections[collection].hide_viewport = False
time_start_2 = time.time()
- batchFolder = os.path.join(config.nft_save_path, "Batch" + str(config.renderBatch))
+ batchFolder = os.path.join(nftBatch_save_path, "Batch" + str(batchToGenerate))
imagePath = os.path.join(batchFolder, "Images", name)
animationPath = os.path.join(batchFolder, "Animations", name)
@@ -118,46 +108,50 @@ def render_and_save_NFTs():
modelFolder = os.path.join(batchFolder, "Models")
metaDataFolder = os.path.join(batchFolder, "BMNFT_metaData")
- if config.enableGeneration:
+ # Material handling:
+ if enableGeneration:
for c in dnaDictionary:
collection = dnaDictionary[c]
- if stripColorFromName(collection) in config.colorList:
+ if stripColorFromName(collection) in colorList:
colorVal = int(collection.rsplit("_", 1)[1])-1
collection = stripColorFromName(collection)
bpy.data.collections[collection].hide_render = False
bpy.data.collections[collection].hide_viewport = False
- if config.generationType == 'color':
+ if generationType == 'color':
for activeObject in bpy.data.collections[collection].all_objects:
mat = bpy.data.materials.new("PKHG")
- mat.diffuse_color = config.colorList[collection][colorVal]
+ mat.diffuse_color = colorList[collection][colorVal]
activeObject.active_material = mat
- if config.generationType == 'material':
+ if generationType == 'material':
for activeObject in bpy.data.collections[collection].all_objects:
- activeObject.material_slots[0].material = bpy.data.materials[config.colorList[collection][colorVal]]
+ activeObject.material_slots[0].material = bpy.data.materials[colorList[collection][colorVal]]
else:
collection = stripColorFromName(collection)
bpy.data.collections[collection].hide_render = False
bpy.data.collections[collection].hide_viewport = False
- print(f"{bcolors.OK}Generating{bcolors.RESET}")
- if config.enableImages:
+ if enableImages:
+ print(f"{bcolors.OK}Rendering Image{bcolors.RESET}")
+
if not os.path.exists(imageFolder):
os.makedirs(imageFolder)
bpy.context.scene.render.filepath = imagePath
- bpy.context.scene.render.image_settings.file_format = config.imageFileFormat
+ bpy.context.scene.render.image_settings.file_format = imageFileFormat
bpy.ops.render.render(write_still=True)
- if config.enableAnimations:
+ if enableAnimations:
+ print(f"{bcolors.OK}Rendering Animation{bcolors.RESET}")
if not os.path.exists(animationFolder):
os.makedirs(animationFolder)
bpy.context.scene.render.filepath = animationPath
- bpy.context.scene.render.image_settings.file_format = config.animationFileFormat
+ bpy.context.scene.render.image_settings.file_format = animationFileFormat
bpy.ops.render.render(animation=True)
- if config.enableModelsBlender:
+ if enableModelsBlender:
+ print(f"{bcolors.OK}Generating 3D Model{bcolors.RESET}")
if not os.path.exists(modelFolder):
os.makedirs(modelFolder)
@@ -170,29 +164,40 @@ def render_and_save_NFTs():
for obj in bpy.data.collections['Script_Ignore'].all_objects:
obj.select_set(True)
- if config.modelFileFormat == 'glb':
- bpy.ops.export_scene.gltf(filepath=modelPath,
+ if modelFileFormat == 'GLB':
+ bpy.ops.export_scene.gltf(filepath=f"{modelPath}.glb",
check_existing=True,
export_format='GLB',
use_selection=True)
- elif config.modelFileFormat == 'fbx':
- bpy.ops.export_scene.fbx(filepath=modelPath,
+ if modelFileFormat == 'GLTF_SEPARATE':
+ bpy.ops.export_scene.gltf(filepath=f"{modelPath}",
+ check_existing=True,
+ export_format='GLTF_SEPARATE',
+ use_selection=True)
+ if modelFileFormat == 'GLTF_EMBEDDED':
+ bpy.ops.export_scene.gltf(filepath=f"{modelPath}.gltf",
+ check_existing=True,
+ export_format='GLTF_EMBEDDED',
+ use_selection=True)
+ elif modelFileFormat == 'FBX':
+ bpy.ops.export_scene.fbx(filepath=f"{modelPath}.fbx",
check_existing=True,
use_selection=True)
- elif config.modelFileFormat == 'obj':
- bpy.ops.export_scene.obj(filepath=modelPath,
+ elif modelFileFormat == 'OBJ':
+ bpy.ops.export_scene.obj(filepath=f"{modelPath}.obj",
check_existing=True,
use_selection=True)
- elif config.modelFileFormat == 'x3d':
- bpy.ops.export_scene.x3d(filepath=modelPath,
+ elif modelFileFormat == 'X3D':
+ bpy.ops.export_scene.x3d(filepath=f"{modelPath}.x3d",
check_existing=True,
use_selection=True)
+ elif modelFileFormat == 'VOX':
+ bpy.ops.export_vox.some_data(filepath=f"{modelPath}.x3d")
if not os.path.exists(metaDataFolder):
os.makedirs(metaDataFolder)
- metaDataDict = {"name": name, "description": config.metaDataDescription, "NFT_DNA": a,
- "NFT_Variants": dnaDictionary}
+ metaDataDict = {"name": name, "NFT_DNA": a, "NFT_Variants": dnaDictionary}
jsonMetaData = json.dumps(metaDataDict, indent=1, ensure_ascii=True)
@@ -202,17 +207,16 @@ def render_and_save_NFTs():
print("Completed {} render in ".format(name) + "%.4f seconds" % (time.time() - time_start_2))
x += 1
- if config.enableResetViewport:
- for a in BatchDNAList:
- for i in hierarchy:
- for j in hierarchy[i]:
- if config.enableGeneration:
- j = stripColorFromName(j)
- bpy.data.collections[j].hide_render = False
- bpy.data.collections[j].hide_viewport = False
+ for a in BatchDNAList:
+ for i in hierarchy:
+ for j in hierarchy[i]:
+ if enableGeneration:
+ j = stripColorFromName(j)
+ bpy.data.collections[j].hide_render = False
+ bpy.data.collections[j].hide_viewport = False
- print("\nAll NFT PNGs rendered, process finished.")
- print("Completed all renders in Batch{}.json in ".format(config.renderBatch) + "%.4f seconds" % (time.time() - time_start_1) + "\n")
+ print(f"\nAll NFTs successfully generated and sent to {nftBatch_save_path}")
+ print("Completed all renders in Batch{}.json in ".format(batchToGenerate) + "%.4f seconds" % (time.time() - time_start_1) + "\n")
if __name__ == '__main__':
diff --git a/src/Main_Generators/Rarity_Sorter.py b/main/Rarity_Sorter.py
similarity index 75%
rename from src/Main_Generators/Rarity_Sorter.py
rename to main/Rarity_Sorter.py
index feeb762..b6e5eb8 100644
--- a/src/Main_Generators/Rarity_Sorter.py
+++ b/main/Rarity_Sorter.py
@@ -5,29 +5,10 @@ import bpy
import os
import sys
import random
-import importlib
from functools import partial
-dir = os.path.dirname(bpy.data.filepath)
-sys.path.append(dir)
-sys.modules.values()
-
-from src import config
-importlib.reload(config)
-
-from src.Main_Generators import DNA_Generator
-
-importlib.reload(DNA_Generator)
-
-
-if config.runPreview:
- config.nftsPerBatch = config.maxNFTsTest
- config.maxNFTs = config.maxNFTsTest
- config.renderBatch = 1
- config.nftName = "TestImages"
-
-def sortRarityWeights(hierarchy, listOptionVariant, DNAList):
+def sortRarityWeights(hierarchy, listOptionVariant, DNAList, nftName, maxNFTs, nftsPerBatch, save_path, enableRarity):
"""
Sorts through DataDictionary and appropriately weights each variant based on their rarity percentage set in Blender
("rarity" in DNA_Generator). Then
@@ -40,7 +21,7 @@ def sortRarityWeights(hierarchy, listOptionVariant, DNAList):
possibleNums = list(range(1, numChild + 1))
listOptionVariant.append(possibleNums)
- for x in range(config.maxNFTs):
+ for x in range(maxNFTs):
def createDNA():
dnaStr1 = ""
for i in hierarchy:
@@ -75,7 +56,7 @@ def sortRarityWeights(hierarchy, listOptionVariant, DNAList):
dnaPushToList = partial(createDNA)
- DNASet |= {''.join([dnaPushToList()]) for _ in range(config.maxNFTs - len(DNASet))}
+ DNASet |= {''.join([dnaPushToList()]) for _ in range(maxNFTs - len(DNASet))}
DNAListRare = list(DNASet)
return DNAListRare
diff --git a/src/Main_Generators/metaData.py b/main/metaData.py
similarity index 80%
rename from src/Main_Generators/metaData.py
rename to main/metaData.py
index b4b0cd1..dff172f 100644
--- a/src/Main_Generators/metaData.py
+++ b/main/metaData.py
@@ -10,23 +10,15 @@ import os
import sys
import importlib
-dir = os.path.dirname(bpy.data.filepath)
-sys.path.append(dir)
-sys.modules.values()
-from src import config
-
-importlib.reload(config)
-
-
-def returnCardanoMetaData(name, description, NFT_DNA, NFT_Variants):
+def returnCardanoMetaData(name, NFT_DNA, NFT_Variants):
metaDataDictCardano = {"721": {
"