text:
Connecting edges with eachother to extend a bevel
so i am modeling a 3D "dollar bil" and i am having an issue, i want to bevel the sides of the bil so it becomes round, but the bevel only moves until an edge(see 2nd picture) so i think i need to combine or connect the 2 edges (the orange and white edge need to becone one) but i don't know how, i hope you can help.

As well as @Gordon Brinkmann's answer, it looks from your second image as if you may need to apply the scale to your object so that the bevel is symmetrical round the corner.. - In Object mode, CTRL-A > apply Scale.

@JohnEason Yes, I guess you're right. If the scale was correct the beveling would look different. I just focused on the problem of joining the edges, but for a good bevel the scale should be applied, too.

Just go into Vertex Select mode, select the vertex which splits the edge and hit Ctrl+X to dissolve the vertex.
Or press X and in the popup menu choose Dissolve Vertices.
Just a sidenote, apart from the split edge it looks like the object bevels unevenly on both sides, so as @JohnEason mentions in his comment it is probably needed that you apply the scale on your object with Ctrl+A > Apply > Scale.

This worked Thanks!

@RyanvanVuure You're welcome. You might consider to accept this answer then.


text:
Imported .obj is not depicted correctly
I hate using blender, but have to do it for university. And I need your help.
I am able to import my objects to blender but they are not depicted correctly. It´s either only the outlines or (in some view positions -) the Surfaces are fragmented. This gets better when I zoom in.
The most important thing I Don´t understand is, that everything works properly when I switch the perspective to orthographic projection. I can not even see the grid anymore and proper zooming and navigating in the viewport also just works in the ortho view.
I tested around with the clipping settings but that doesn´t help.
please tell me any Idea you have, I am so desperate.

Ideally Clip Start should be as large as possible and Clip End should be as small as possible. Try a Clip Start of like 0.01.

This looks like a floating point precision error. Change the clip start / end and check if your meshes are not millions of units away from the origin world

In this case I suspect Clip End.

You guys are my hero´s for today, thank you! didn´t expect it to be that easy because I´ve already plaed around with that.

@Skiffit Your first sentence is a great way to win the hearts of us Blender admirers :D Anyway, glad you found the solution here.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Weight painting acting weird on certian faces
I tried editing weigth painting but when I got to a certain place, the weight doesn't seem to affect that spot. I tried using the blur tool, it just expands that spot more. Lots of help are appreicated, thank you! (I also turned on auto-normalize)

Related: https://blender.stackexchange.com/questions/247416/why-sometimes-vertices-cant-be-colored-in-weight-paint-mode/247421#247421

Check normals and double vertices also.

I already did, it looks fine to me

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
How to model a ruffles that actually attaches to a piece of clothing
I was wondering how I can make something that looks like this in blender and some wrinkles on clothes that have less triangles/verts. Thank you for your help!

Maybe switch to Sculpt mode and use the Cloth brush. In the N panel > Tool > Deformation > choose Pinch Perpendicular. Use the Mask brush if you want some parts not be affected:


text:
Can I reuse blender animations?
Before I begin wasting hours of my life, can I reuse blender animations that I made for one model?
Let's say I animate directly a rig armature, then apply it to a character, will it work? or do I to to do idle animations, walks, runs, climbing... and all that stuff for every single model?
Let's say I make a character and then want to change their hair or clothes, do I need to remake all animations over again?

you can use the same animation for several objects, you'll need to parent the object correctly though

Further detailing what moonboots has already said: If the skeleton is structured and named exactly (in caps)  the same way, it is possible to copy an animation from one skeleton to another.

If the skeleton doesn't differ too much, you can remove the mesh, lay another on top and reparent with automatic weighting. Works fine.


text:
Which of these 2 Video Cards are better for Blender?
I am new to blender and I need a video card for my computer, I only have two affordable options

nVidia GEFORCE GT 730 4GB DDR3 128BIT
nVidia PNY QUADRO T400, 2GB, GDDR6, 64-BIT

I am not a gamer, which one of these cards is better for modeling, animating, and rendering 3D in blender?

It is more of a hardware issue than a Blender problem.  I will say this:  the video card does make a difference in your work flow in terms of time, especially with rendering.

From what I can tell using userbenchmark, the T400 blows the GT 730 out of the water. And that makes sense, it’s much newer and also designed for workbench use.
For that reason I would recommend you use the T400, it should suit your needs much better than the GT 730


text:
I accidentally set an object as camera, how do I undo this?
I have a problem with rendering in cycles.
In blender render my object is rendering fine, but in cycles when I pushed F12 I got only this:

One more thing: when I click 0 on keyboard I'm not in camera persp, but in object as camera, it looks like invisible layer, I don't know how to undo this, and be in camera persp again.
Does anybody have any idea how to fix this?

Please upload your .blend file.

If you just switched from BI to Cycles you probably don't have materials defined for Cycles, you need to recreate the materials in Cycles nodes.

Zoom out or select a camera from the outliner and press Ctrl Numpad 0.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
How to import and rename a series of objects with python
I have a scene where you have multiple objects, and want to import and rename them as only cone1, sphere1, cube1. I do not want Blender to automatically rename New_cone_New_cone.025 for example, which is very strange. I want to make it with code in python.

When you say "import" do you mean from an alien file format (like .OBJ) or link from another .blend file?   What are the rules for renaming?

Without any good rules for renaming I'm going to offer this code snippet as a starting point:
import bpy

for obj in bpy.context.scene.objects:
    if obj.select:
        obj.name = "bacon"

This will rename every selected object to "bacon", although blender will notice that is a duplicate and append suffixes like .001, .002 automatically.
If you need something fancier feel free to add some detail to the question and I'll complicate my answer.

To an empty scene, I want to import a list of some and different objects to the scene. The file format is .OBJ

in blender's File menu there is an Import submenu with Wavefront(.obj) as an option.  That should cover the importing.  I do not think there is a way in python to override the naming logic of that operation, so your best bet is to rename the objects after they have been successfully imported.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
How do I make varying curve bevel?

How do I approach to create a model like this?

if you want to use curves to make these parts you can vary their radius or use a taper object, but you can also simply model it with a mesh

Looks like you have the mesh object and want to boolean away a curve from the center.  Does this help? https://blender.stackexchange.com/a/58567/110840

what do you meam by simply model with a mesh

Here is what I do for such shape.

Use a Bezier curve, in this example called "path to follow" for the general curving shape.
Use a different Bezier curve, in this example called "bevel shape" for the shape you have drawn in red.
Use a third Bezier curve, in this example called "taper" to control how the bevel tapers from one end of the path to the other.

After I've created the 3 curves, but before I tune them, I set the Object Data Properties for the "path to follow" curve by going to the object data properties for the curve and adding the "taper" curve to Geometry as the Taper Object and the adding the "bevel shape" Curve to Bevel as the Object after setting the Bevel type to Object:

Here's a funky object I created this way

The "Path to follow"

The "taper"

and finally, the "bevel shape"

Notice that for simplicity that they all sit on the same plane and have the same origin.  That's not required. Experiment to see what effect moving and rotating them has.
I strongly recommend giving the curves unique names.  It's very easy to screw up and use the wrong curve as the bevel or taper, or to apply bevel or taper to the wrong curves.


text:
How to open 2.90(2.80+) blend file in 2.79
I can't find solution how to open .blend file that are 2.80+ version, into 2.79 version.
I tried with Ctrl + C and Ctrl + V -> it works only for object, the textures are missing.
Any solutions?

Have you tried 'appending' the objects? Why 2.79?

With appending the results is same as the image above. I need 2.79, because there is addons exporter, that doesn't support 2.80+

In general you can't expect files from newer version to properly open in older versions. Blender provides backward compatibility but not forward compatibility. In this case there are likely issues with the material and texture setup. You may want to try to change the render engine to Cycles, since Blender Internal doesn't exist in versions past 2.79 thus the file doesn't contain any material definitions for this render engine.

What exporter? @Rumen

This exporter: https://sourceforge.net/projects/blenderextrainz/files/BlenderXML%20exporter%20for%20Trainz/x0.96/


text:
Duplicate materials
I've got a question: How can I connect the .000 and .001 materials to one ? Because I want to use separate by Materials on my object, but it separates the duplicate materials too. (.000 and .001)
Example pictures:

Are duplicated materials which you'd like to get rid of unused ones, i.e. unused by any other object in scene ? This can be checked by number 0 next to the material name in the dropdown list of materials.

This addon fixed the datablock issue:
https://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/3D_interaction/Datablock_Tools

If I understand you correctly you can either:
In the Materials Pane select the materials you don't want to use and then click the button with the “-“ symbol on it to remove the materials from your object. Note that the material will still be available to you in the material drop down menu.

Or
Select your object and “Tab” into Edit Mode then select the Face(s) that you want to add a color then in the Materials Pane select a material and the press the “Assign” button. Note that this option is only available in Edit Mode.

Thanks, but I have 90 meshes in my real model and it would be very long time to do this with the all of the meshes.

Can you upload your .blend file here? http://blend-exchange.giantcowfilms.com/

Sorry, The model isn't public.

You can try adding one of the materials to both cubes. This should leave the other material unused (a 0 should appear next to its name in the materials menu). Also make sure the unused material doesn't have the F next to its name selected. The F, Forces it to hang around even when it shouldn't.
Once you can see the 0 next to it in the list, save your file, close out of Blender, and reopen your file again. Your 0-ed material should have disappeared during the refresh.

What is F Forces ?

@Vettel.Sebastian Sorry for being unclear. I meant the F, Forces blah de blah to happen. If my answer helped, please consider accepting it.

I just want to remove the .number from my materials, nothing special.

Then click either once or twice on the name to edit it. Once again, please consider accepting my answer.


text:
Insert Blank Keyframe with Grease Pencil not working + Time Offset Modifier
I created a basic walk cycle in Grease Pencil and with time modifier looped it.
Now that I am trying to insert blank keyframes to the same to terminate it, and work again in the same layer it is not possible.
Despite inserting blank keyframe the loop does not disappear. How do I stop the time offset loop and get a blank keyframe?

A possible way is using Grease Pencil with the NLA editor as described HERE

This Q was a result of a FLASH mindset where I can cut the loops as I wished.
Apparently in GP we cannot make these loops and cut as wish.
So, I copy pasted the frames as many times as needed, not the most beautiful solution but it works.


text:
How to bake a fake SSS map (thickness map)
I am creating a character and I want to bake a fake SSS map that I can combine with my albedo map for my character and save resources instead of calculating the SSS in real time.

I made a tutorial about this. Maybe someone will find this useful. https://youtu.be/qlUcSBiThWE

Note: you must use a version above 2.79 to have access to the AO node: https://builder.blender.org/download/

Create an Emissive shader then add an Input → Ambient Occlusion. Check Inside and Only Local (surrounding objects won't affect the AO). For the distance I have used 0.4 on Suzanne but you can tweak it depending on the model and scale (don't forget to apply the scale with Ctrl+A → scale).

To add blood directly on your model:

add a Mix node and set the first color to black, connect the inverted AO to the second slot. The factor of the node allow you to adjust the amount of blood that will be visible.
Add another mix node, connect the previous mix node to the factor, do not display too much blood. Set the first color to the base color and the second to the blood color. For the blood you can use R: 0.7 GB: 0.1.
Optionally overlay it to an Input → Geometry Pointiness node, use a Converter → ColorRamp at 0.45 — 0.55 to contrast it.
Finally multiply it to an Ambient Occlusion map if you use an emissive shader, otherwise the AO will be added with your scene's lighting.

Tip: you can adjust the samples of the AO depending on how much visible it is to render or bake faster.


text:
How to generate a fake hand painted texture (Blizzard like), Borderlands effect or Pixel Art effect
I want to generate a texture that looks like it has been hand painted to use with a game asset by baking the details of the high poly on the low poly, then composite the textures to get an hand painted texture effect without having to paint.
What texture do I need, how should i compose them and is there a technique to generate good colors?

Hand painted effect
One texture is needed: a normal map. I recommend you to bake it in 32 or 16 bits float in order to get more depth on your curvature map and to bake it at a minimum resolution of 2048*2048.
Once it's baked you will need to generate two maps from it:

Generate a curvature map from a normal map: https://blender.stackexchange.com/a/72602/23134
Generate a smooth curvature map from a curvature map: https://blender.stackexchange.com/a/100637/23134
to the second slot. We don't use Multiply so the value of your color will have no effect on your texture.

The node setup is simple, you must overlay the two maps, the order makes a subtle difference:

if the curvature smooth map is in the first input of the overlay node the details from the curvature map will be shadowed so it's more realistic I recommend it.
if the curvature is plugged on the first input, the details on it won't be shadowed making the result less realistic.

Add a value node, for the first input add a color ramp in between your curvatures and the value node, on the second input the curvatures. This will allow to use the curvature to change the brightness of the color so you don't have to worry about the value of your colors.
On the color ramp for the left cursor pick a cold color, it's a color closer to blue and saturated (= a lot of color), for the right cursor pick a warm color closer to yellow and desaturated (0.5 saturation maximum, you can go higher for effects like lava).
The result:

Top lighting
To create a top lighting effect for stylized games Diffuse/Color map (PBR games do not use lighting informations in their albedo textures) you can bake an Object Space normal. You can get more informations here on how to bake it: https://blender.stackexchange.com/a/72664/23134
Once it's baked you will need to separate the Green channel (it depends on your axis it can be another channel) to get a top lighting effect. Then you must overlay it to the curvature. Adjust the value, the default 1 adds too much lighting informations.

Texture a game character or creature (and how to make it a sprite)
To add some SSS on your albedo map you must bake a thickness map: https://blender.stackexchange.com/a/100725/23134
Like before all your map must be imported in Linear mode and you must again overlay the curvature smooth with the curvature map for your grayscale then add a value node and use a color ramp in HSV mode to pick the analogous colors. For the thickness map mix it with the base albedo, use a color ramp with R: 0.7 GB: 0.1 for the blood color, you don't need to touch the right cursor. For the factor of the mix node add a color ramp with the left cursor in RGB: 0.1 (you can adjust this value for the amount of blood visible, brighter = more blood visible) and move the right cursor to the middle (position 0.5). Then you can connect the alpha of the thickness map to the alpha of the output node for the transparency if you are baking a sprite.

Drawn lines effect
You can use a color ramp node in constant mode to fake a texture with drawn lines. On the color ramp the left cursor has a dark value the right cursor has the background color. The more you move the right cursor to the left the more lines disappears. Then add a relative blur. You can adjust the Pixel Width for the thickness of the lines.

You can overlay the curvature with the lines with the curvature smooth at 0.5 for example to get more color variations:

Retro texture effect
For a retro effect GIMP is needed. Import your fake hand painted texture, I recommend you the one with the top lighting effect.
Change the saturation, old games had saturated colors. Go in Color > Saturation..., you can increase is by 25% by entering 1.250.
Reduce the scale of the image, go in Image > Scale Image..., you can set it to 512x512, bellow too much details are lost for this texture. For the interpolation select None, using an interpolation will make the image blurry.
To reduce the number of color go in Image > Mode Indexed, enter the number of color you want. Use a very low number like for example 5 (at 4 the black color for the shadows wasn't visible). I suggest you to use a dithering effect it create a smooth color transition by adding points of the same color, the positioned effect gives a more retro style by placing the pixel more like a checkerboard.
Reset the scale of the image, if you export it in 512x512 in PNG the image will be blurred even with no compression. Set it back to 2048x2048 without interpolation.
Here is the result:

Should I export a Diffuse or Albedo map?

A diffuse map is a texture for non-PBR games (also means less real time lighting and less ressources used ideal for mobile games) so the map can include some lighting informations like using a multiply with an ambient occlusion or a soft light with a color channel of an object space normal map to add top lighting. You can also use them with an unlit shader so they do not receive any lighting and shadows for better performances.
In PBR we use an albedo that contains no lighting information (or a little amount for stylized textures) to make the asset works in every real time lighting conditions. Stay with the curvature and thickness map only. The ambient occlusion must be imported separately in the shader so it is only visible in the shadowed part of your asset and disappear when hit by direct lighting (for that you must set your game engine in deferred lighting instead of forward). Also use Linear color space in your game engine instead of gamma to make your PBR textures more realistic.

Where to use them?
Fake hand painted textures are popular on mobile games, MOBA and MMORPG. Those textures can be used as an hand painting base to finish them manually.
Those textures are popular on the Dota 2 Workshop, you can learn how to create an asset for the game here: https://blender.stackexchange.com/a/101830/23134


text:
How to create a Cycles material with python to bake a curvature map
I want to make a script that bake a curvature texture at the resolution set automatically (i am creating a script that bakes every maps at once).
The script needs to create a textures, use the resolution entered, create a material with an emit shader and for the input a Geometry > Pointiness then a Color Ramp at 0.4 then 0.6.
It needs also to check is there is an existing node and texture with the same name already, if yes it should remove it. Then the script save the texture.
I have started the beginning of the script, the material part is missing:
import bpy

size = 2048, 2048

# create the texture, delete the old texture
image = bpy.data.images.new("curvature", width=size[0], height=size[1])

# create the material nodes, delete the old texture
bpy.data.materials.new("CURVATURE")

# to use once the material is created correctly
#bpy.data.objects['HP'].active_material = bpy.data.materials['CURVATURE']
#bpy.data.objects['LP'].active_material = bpy.data.materials['CURVATURE']
#bpy.ops.object.bake(type="EMIT", use_selected_to_active = True, use_cage = True, cage_extrusion = cage_size, margin = edge_padding, use_clear = True)

#need to get the name of the image on the variable image
image.filepath_raw = "//curvature.png"
image.file_format = 'PNG'
image.save()

Just to note: If you need real curvature map (1st surface derivative), you won't get it from Pointiness or Dirty Vertex Colors. Blender does generate these maps a bit differently (looks like it's 2nd surface derivative).

How can i get a better curvature map?

You can see info here: http://wiki.polycount.com/wiki/Curvature_map. But these are codes for Max, Maya or Lightway. You may find an OSL shader to use or you will have to write your own.

zero025 helped me to code it:
import bpy

#Generate the textures and shader
#################################
#Get texture in data-block
###########################
tex = bpy.data.images.get("curvature")

#If exist or not
#################
if  tex is None:
    #create texture in data block
    tex = bpy.data.images.new("curvature", width=size[0], height=size[1], alpha = True)

    #Create material nodes "CURVATURE"
    ################################################################

    # Test if material exists
    # If it does not exist, create it:
    mat = bpy.data.materials.get("CURVATURE")

    if  mat is None:
       mat = bpy.data.materials.new("CURVATURE")

       # Enable 'Use nodes':
       mat.use_nodes = True
       nt = mat.node_tree
       nodes = nt.nodes
       links = nt.links

       # clear
       while(nodes): nodes.remove(nodes[0])

       d_geometry  = nodes.new("ShaderNodeNewGeometry")
       d_colorramp = nodes.new("ShaderNodeValToRGB")
       d_emission = nodes.new("ShaderNodeEmission")
       d_output   = nodes.new("ShaderNodeOutputMaterial")
       d_image   = nodes.new("ShaderNodeTexImage")

       d_geometry.location = (-100,-100)
       d_colorramp.location = (200,-100)
       d_emission.location = (500,-100)
       d_output.location = (700,-100)
       d_image.location = (300,300)

       d_image.image = tex
       d_colorramp.color_ramp.elements[0].position = 0.4
       d_colorramp.color_ramp.elements[1].position = 0.6

       links.new( d_output.inputs['Surface'], d_emission.outputs['Emission'])
       links.new( d_emission.inputs['Color'], d_colorramp.outputs['Color'])
       links.new( d_colorramp.inputs['Fac'], d_geometry.outputs['Pointiness'])

#BAKING
#########################

#Curvature map

#remove every material slot of the high poly
bpy.ops.object.select_all(action = 'DESELECT')

bpy.ops.object.select_pattern(pattern="tmpHP")
bpy.context.scene.objects.active = bpy.data.objects["tmpHP"]

for ob in bpy.context.selected_editable_objects:
    ob.active_material_index = 0
    for i in range(len(ob.material_slots)):
        bpy.ops.object.material_slot_remove({'object': ob})

bpy.ops.object.select_pattern(pattern="tmpLP")
bpy.context.scene.objects.active = bpy.data.objects["tmpLP"]

print("\n> Baking: curvature map\n")

bpy.data.objects['tmpHP'].active_material = bpy.data.materials['CURVATURE']
bpy.data.objects['tmpLP'].active_material = bpy.data.materials['CURVATURE']
bpy.ops.object.bake(type="EMIT", use_selected_to_active = True, use_cage = True, cage_extrusion = cage_size, margin = edge_padding, use_clear = True)


text:
How can i optimize the polycount of hard surface game assets?
After doing a retopology i want to check if i can optimize the polycount even more by removing unacessary edges that doesn't affect the silhouette of my hard surface game asset with flat surfaces, is there a quick way to do that?

Here is a method to optimize hard surface models with a lot of flat surfaces for round shapes a decimation is preferable:
You can combine muliple tools or modifiers to remove the edges that doesn't affect the silhouette automatically.
The modifier has the advantage that you can keep modeling/retopologizing while your game asset will be automatically optimized, but you will need to apply the modifiers and unfold the UVs for a correct result.
Shortcuts
With the shortcuts go in Edit Mode (it's for the low poly to look good with a smooth shading, so it's purely optionnal), select everything and press x then Limited Dissolve, this will remove by default every vertices at an angle of less than 5 degrees, you can change this value in the "t" menu. Blender will keep one (bad) edge on some faces it depends of their shape. Then do Ctrl + t to add triangle.
Redo a limited dissolve then Ctrl + t to remove the bad edges that were created.
Modifiers
With modifier add an edge split modifier then a decimation modifier in Planar mode Sharp. Change the angle of the split modifier until you get the result you want.
Then add a triangulate modifier.
Like for the shortcut version you must redo the decimation and triangulate to remove the first edges that weren't placed correctly.


text:
How to create dota 2 assets ? (Steam Workshop)
I want to model, export and compile an asset made in Blender to the game Dota 2, which tool(s) do I need and what are the settings?

Installing the tool to export to Dota
To export your model into Dota you will need to export it in .DMX with the addon "Blender Source Tool": http://steamreview.org/BlenderSourceTools/ (don't unzip it)
To install the add-on go in File > User Preferences... in the Add-ons tab click "Install Add-on from File..." and select the .zip. Type "Source" in the search bar and make sure it is enabled.

Importing and editing a game character from Dota
You need to import a character, your model won't compile if it's not attached to the armature of it. You can find the heroes of the game here:
http://www.dota2.com/workshop/requirements
Import the SMD files with the add-on if there is only an FBX, they often have a bug with the scale of the bones, if this happens read my post bellow on how to fix it.
To import your SMD files you can use shift and left click to highlight the files and import them all at once. Each SMD have the armature but it will be imported once.
The model will be laid down horizontally and be very big in the viewport, you can orient it correctly and apply the rotation but you will need to keep the same scale when exporting. You can scale the bones to 0.01 to model your assets.
In this example I am adding the head of Suzanne on top of the head of the heroe Alchemist.
To attach it to the armature, select the model you have made first then the armature, then press Ctrl+p and select "With Empty Groups".
To bind the model to a bone you need to go in the property menu, in the Data tab with a triangle as an icon, in the Vertex Group menu. You will see every bones listed, to order them alphabetically click on the black arrow pointing downward then click "Sort by Name".

In edit mode select the vertices you want to bind to a bone, I select the entire Suzanne head, stay in edit mode and in the menu I select the head bone and click Assign with a Weight of 1 (1 = fully connected).

Now to test it I select the head bone in Pose mode and move it, the model now moves with it, if not check if it is connected to the correct Vertex Group.
Exporting your model
In the property menu go in the Scene tab, it's the third tab from the left. Scroll down to Source Engine Export. Set the path where to export it. For the format make sure it is DMX. Change the DMX Version to the highest numbers: Binary 9 and Model 22.
Note: you can't name your DMX, you must name your asset in the "n" menu. The file will take the name of the active selection.

You can also create a basic normal map to test your model, by creating an image filled with the color RG: 0.502 B: 1.
Compiling and testing in game
To test your asset in Dota 2, right click on the Dota 2 game on Steam and go in Properties. Click on the DLC tab and check Dota 2 Workshop Tools DLC, steam will automatically download it.
When you will launch Dota, a pop-up window will ask you if you want to launch the game or the workshop tool (if it doesn't appear it means the download isn't finished), select the second.

Click on Create New Item, then Hero Item..., select your hero and slot that your asset will replace, then click Select.
Name your asset you can't use uppercase and spaces.
Import the normal map. For the color map (diffuse map) you can use a basic color texture to test your model and silhouette.
For now set the Specular Intensity Mask with RGB at 0.1 because on some heroes the asset is too shiny and a Rim Intensity Mask at RGB 0.2.

If you get an error during the compilation here are the things to check:

Your asset must be attached to the armature even if there is no bone weight.
Your asset must have UVs.
Your asset must have a material (Cycles or Blender Render).
If the asset isn't visible make sure you have reseted the scale of the armature with Alt+s.
The color or normal map are missing.
The texture resolution and polycount are too high, but this is just to publish your asset, it will compile without the correct values you can check the values in the hero download page.
You haven't export in Binary 9 and Model 22 version.

You can play the different animations, by default it's on idle and the Preview in game will launch the game.
Do a test in the Dota map, remember that most details are seen from the top view, remove unnecessary details.
Textures
For the textures use a suffix, for example alchemist_head_color.tga. Use the TGA format and the texture resolution of the hero requirement page.
Here are all the suffixes in the same order than the Workshop settings:

_color.tga (I explain how to create this texture here: How to generate a fake hand painted texture (Blizzard like), Borderlands effect or Pixel Art effect)

_transparency.tga
_normal.tga (base RG: 0.502 B: 1)

_detailMask.tga
_fresnelWarp.tga
_metalnessMask.tga (RGB: 0 = non metallic, RGB: 0.6 = metallic)

0:

0.6:

_selfIllumMask.tga
_specularMask.tga (RGB: 0.22)

_rimMask.tga (RGB: 0.2 = non metallic, RGB: 0.6 = metallic)

0.2:

0.6:

_tintByBaseMask.tga
_specularExponent.tga

Valve has made a post with advice on texturing: https://support.steampowered.com/kb/9334-YDXV-8590/dota-2-workshop-character-art-guide
More informations about the different maps: https://support.steampowered.com/kb/3081-QUXN-6209/dota-2-workshop-item-shader-masks
Fixing the bones (if an FBX is used)
When the SMD files aren't available the only option is the FBX. In this format the bones aren't oriented and scaled correctly, but we can export a .DMX from Source Filmmaker.
In Blender import the .FBX an delete the armature, the character will lay down, orient it correctly, you can apply the rotation. If you change his scale don't apply it.
To download Source Filmmaker go in your Library of games and change the Games menu at the top to Software, you will see Source Filmmaker, do not launch it from there because you won't have access to the Dota assets.

Launch the Dota Workshop tools and click at the bottom on "Launch Custom Game Tools".

A window will open called Asset Browser, click on the Source Filmmaker icon at the top it will launch it.

Create a new session, name it whatever you want.
Open the Animation Set Editor tab at the top left and click on the "+" icon then click on "Create Animation Set For New Character".

Then choose your heroe, it will appear in the viewport.
Now do a right click on the heroe name followed by a 1, it is the first line and select Export > Animation. This will export your model in his default pose with his armature, you can name the file heroename_rig_fix for example.

Import the asset it's a .dmx. Go in Pose Mode, it's important that you use this mode and not the Object Mode. So in Pose Mode select every bones with "a" then press Alt + g and Alt + s, the armature will be horizontal and on the side.
In Object Mode orient the rigging to match the heroe then apply the rotation.
Select every meshes of the heroe and in the modifier tab assign the armature, if the mesh doesn't move it means the armature is oriented corectly. In Pose Mode the character should move with the rigging.

Create a courrier

Default courrier model: http://media.steampowered.com/apps/dota2/workshop/courier.zip
More informations: https://support.steampowered.com/kb_article.php?ref=8986-WRAZ-1046

Courrier requirement:

Two courriers one on the ground and the other flying each with a LoD1 and eventually a LoD0. You can use the suffix _model for the one on the ground and _wind for the other
LoD0 (optional, used for the portrait): 3500 triangles
LoD1 (in game): 3000 triangles
Texture resolution: 512x512
Animations: Spawn (ground only), Idle, Run, Die
Special bones: attach_hitloc (where the attacks land), left eye, right eye

Create a ward

Default ward model: http://media.steampowered.com/apps/dota2/workshop/ward.zip
More informations: https://support.steampowered.com/kb_article.php?ref=8799-WLXN-3860

The observer ward and the sentry ward share the same mesh and UVs, the only difference is there texture. What differentiate them the most is the color of the eyeball, this is why it must be big and visible from above.
Ward requirements:

LoD0 (optional, used for the portrait): 2000 triangles
LoD1 (in game): 1500 triangles
Texture resolution: 256x256
Animations: idle, idle_alt, run, spawn, turns, wings_die, wings_idle, wings_run, wings_run_alt

Particle effects
More informations: How to create dota 2 assets ? (Steam Workshop)
The following heroes require effects for their weapon(s): Abaddon, Anti-Mage, Bounty Hunter, Doom, Ember Spirit, Juggernaut, Kunkka, Phantom Assassin, and Skywrath Mage.
You must create a contour of you mesh with an higher vertex count than your weapon for an higher precision.
Export the DMX separately, use the same name than the weapon and add the suffix "_fx".


text:
How to get a smooth curvature map from a normal map?
I am trying to generate a smooth curvature map from a normal map. I already know how to generate a sharp curvature (from this post: How to convert a normal map into a curvature map )
Here is the normal map source that i got from the free pack "Rock and boulders 2" of Unity:
High quality normal map for your test: https://drive.google.com/file/d/0B1wP1Y8dmh8aVmN6VUpYMU02Q28/view?usp=sharing

The result i am trying to get in the compositor:

(and the sharp curvature that i can already make in Blender, it uses 1 pixel width)

My goal is to import the curvature smooth and sharp in Linear mode and overlay them together to generate a greyscale, then a color ramp will be used to generate the albedo. I am trying to reproduce this hand painted effect texture: https://youtu.be/dE0CM1C_soc

Suggest adding images to question instead of the google drive links.

I don't think it would be easy to do that in compositor... maybe the best would be to use python and numpy for calculating all the necessary derivatives of the normal map.

http://developer.download.nvidia.com/assets/gamedev/docs/nmap2displacement.pdf Is this you problem? Then you probably won't find any good solutions and certainly any solutions that work in the compositor alone.

I have generated the curvature smooth from a normal map in Substance Designer with the Curvature Smooth node, that means it can be done in the compositor.

@DanylBekhoucha - Are you looking for another answer other than the ones already given?  If so please specify what those answers are lacking with regard to your expectations.

Hi, nobody has found how to get the same result yet but they are close. The same result is important to get an high quality greyscale with every details and to work on it with color gradient

@DanylBekhoucha I’m happy to revisit my script if you let me know what the problem is.

Generate a smooth curvature map from a normal map
To generate the curvature smooth you need first to create a node group of the curvature map, you can find the setup here: https://blender.stackexchange.com/a/72602/23134
Use the first node setup, you will need to replace the three Linear Light nodes to Mix and keep the same values at 0.5.
You can download all the node setups here: https://drive.google.com/file/d/1bixkxs6cSes-J9GVwDeIP7pW2OnGNhYd/view?usp=sharing
But you must not:

overlay the curvature on itself, the curvature must not be contrasted
multiply the blue channel
use the gamma node, every curvature maps must be bright (in sRGB) to overlay them

Note: I recommend to use a normal map in 32 bit Float to get smoother color variation.
To use it add several node group and increment the pixel width by a factor of 2 starting at 1 to 64: 1, 2, 4, 8, 16, 32, 64.
For each of them add a blur node with a value that is double the pixel width: 2, 4, 8, 16, 32, 64, 128
Then overlay every nodes between them in the order you want, I prefer to start from the bottom so the last overlay is at the top like the image input:

How to avoid revealing the seams?
The curvature smooth compared to the curvature map can reveal your seams, it is more noticeable if you are using a Smart UVs projection.
To reduce the visibility of the seams you can:

add a noise bump map on your model that is baked on the normal map, the tiny details will make the seams less noticeable.
make a procedural tillable texture or procedural sculpt on a plane, your texture will be projected in Box mode (Box Mapping in the Unwrap menu or Input > Texture Coordinate, use Object and set the texture to Box instead of Flat and tweak the Blend value to remove the seams like 0.1).

What you can do with the curvature and curvature smooth map:

If you want to fake an hand painted effect, follow this technique: https://blender.stackexchange.com/a/90153/23134
You can use those maps and invert them to generate a roughness map (make sure that the image is displayed in sRGB)

Can you recreate the result in the shader editor?

Python can be used to analyse your normal map and reconstruct the bump map and this can then be used to generate a curvature map.
Here's the code to run - simply paste this into a Text Editor window, load your image into the Image Editor, ensure it has '_nmp' or '.nmp' somewhere in the filename and click 'Run Script'.
import bpy
import os
import math

pixels = None
width = None
height = None

def get_pixel(x, y):

    global pixels, width, height

    base = (y*width+x)*4
    return (pixels[base], pixels[base+1], pixels[base+2], pixels[base+3])

def set_pixel(x, y, rgba):

    global pixels, width, height

    base = (y*width+x)*4
    pixels[base] = rgba[0]
    pixels[base+1] = rgba[1]
    pixels[base+2] = rgba[2]
    pixels[base+3] = rgba[3]

#Adapted from http://blender.stackexchange.com/a/80047/29586
def srgb_to_linear(c):
    a = 0.055
    if c <= 0.04045:
        return c / 12.92
    else:
        return ((c+a) / (1+a) ** 2.4)

# RGBA was previously held as 8-bit. Re-normalize to correct for 8-bit innacurracies
def normalize_normal(rgba):
    dist = math.sqrt(math.pow(rgba[0],2) + math.pow(rgba[1],2) + math.pow(rgba[2],2))
    if (dist > 0):
        return (rgba[0]/dist, rgba[1]/dist, rgba[2]/dist, rgba[3])
    else:
        return (0,0,0,0)

def calc_gradients(normal_x,normal_y):
    adj_x = (normal_x - 0.5)*2
    adj_y = (normal_y - 0.5)*2

    # Filter out the extremes to avoid infinities
    if adj_x < -0.99:
        adj_x = -0.99

    if adj_x > 0.99:
        adj_x = 0.99

    if adj_y < -0.99:
        adj_y = -0.99

    if adj_y > 0.99:
        adj_y = 0.99

    return (math.tan(math.asin(adj_x))/100, math.tan(math.asin(adj_y))/100)

def normalize(arr, width, height):
    #Get range of depth
    max_depth = -99999999999999999999
    min_depth = 9999999999999999999
    for x in range(0,width):
        #print("Normalizing(1)... %i" % x)
        for y in range(0,height):
            depth = arr[y*width+x]
            if depth < min_depth:
                min_depth = depth

            if depth > max_depth:
                max_depth = depth

    print("max = %f, min = %f" % (max_depth, min_depth))
    if max_depth > 1000:
        print("Limited max to 1000")
        max_depth = 1000

    if min_depth < -1000:
        print("Limited min to -1000")
        min_depth = -1000

    if max_depth == min_depth:
        max_depth = min_depth + 1

    #Normalize depth to 0.0 to 1.0 range
    for x in range(0,width):
        #print("Normalizing(2)... %i" % x)
        for y in range(0,height):
            depth = (arr[y*width+x] - min_depth) / (max_depth - min_depth)
            #print(depth)
            arr[y*width+x] = depth

def generate_curviness(heights, width, height, radius):
    #determine curviness at each point and store in RED channel
    curviness = [0.0] * width * height
    print("Calculating Curviness (%i)..." % radius)
    for x in range(1,width-1):
        for y in range(1,height-1):
            for d in range(1,radius+1):

                if (x-d)<0 or (x+d)>=width or (y-d)<0 or (y+d)>=height:
                    pass
                else:

                    h = heights[y*width+x]
                    hv1 = heights[(y-d)*width+x]
                    hv2 = heights[(y+d)*width+x]
                    hh1 = heights[y*width+x-d]
                    hh2 = heights[y*width+x+d]

                    if hv1 < hv2:
                        vcurviness = (h - hv2) - (hv1 - h)
                    else:
                        vcurviness = (h - hv1) - (hv2 - h)

                    if hh1 < hh2:
                        hcurviness = (h - hh2) - (hh1 - h)
                    else:
                        hcurviness = (h - hh1) - (hh2 - h)

                    curviness[y*width+x] += (vcurviness + hcurviness)/(d*d)

    return curviness

def process_image(image_name, new_image_name):

    global pixels, width, height

    image = bpy.data.images[image_name]

    width = image.size[0]
    height = image.size[1]

    # The source image pixels - stream of R,G,B,A for each pixel, width x height
    pixels = list(image.pixels)

    # Gradient from each pixel in each direction - up, left, right, down
    gradient_u = [float] * width * height
    gradient_l = [float] * width * height
    gradient_r = [float] * width * height
    gradient_d = [float] * width * height

    # Determine gradient in each direction for each pixel
    for x in range(0,width):
        print("Capture gradients - Column %i of %i" % (x,width))
        for y in range(0,height):

            this_rgba = normalize_normal(get_pixel(x, y))
            this_rgba_gradient = calc_gradients(this_rgba[0], this_rgba[1])

            if x == 0:
                left_rgba = None
                left_rgba_gradient = (0,0)
            else:
                left_rgba = normalize_normal(get_pixel(x-1, y))
                left_rgba_gradient = calc_gradients(left_rgba[0], left_rgba[1])

            if y == 0:
                bottom_rgba = None
                bottom_rgba_gradient = (0,0)
            else:
                bottom_rgba = normalize_normal(get_pixel(x, y-1))
                bottom_rgba_gradient = calc_gradients(bottom_rgba[0], bottom_rgba[1])

            if x == (width-1):
                right_rgba = None
                right_rgba_gradient = (0,0)
            else:
                right_rgba = normalize_normal(get_pixel(x+1, y))
                right_rgba_gradient = calc_gradients(right_rgba[0], right_rgba[1])

            if y == (height-1):
                top_rgba = None
                top_rgba_gradient = (0,0)
            else:
                top_rgba = normalize_normal(get_pixel(x, y+1))
                top_rgba_gradient = calc_gradients(top_rgba[0], top_rgba[1])

            # Average each directional gradient with this one to give the gradient between the pixels in each direction
            gradient_u[y*width+x] = (this_rgba_gradient[1] + top_rgba_gradient[1])/2
            gradient_d[y*width+x] = -(this_rgba_gradient[1] + bottom_rgba_gradient[1])/2
            gradient_l[y*width+x] = -(this_rgba_gradient[0] + left_rgba_gradient[0])/2
            gradient_r[y*width+x] = (this_rgba_gradient[0] + right_rgba_gradient[0])/2

            # Store it
            ent_u[y*width+x]))
            set_pixel(x, y, (this_rgba[0], this_rgba[1], this_rgba[2], gradient_u[y*width+x]))

    # Now start with 0's and process the whole image pixel by pixel averaging the resulting heights generated by the surrounding pixels
    heights = [0.0] * width * height
    numpasses = int(max(width, height)/2)
    for p in range(0,numpasses):
        print("Pass %i of %i" % (p, numpasses))
        for x in range(0,width):
            for y in range(0,height):
                if y < (height-1):
                    height_top = heights[(y+1)*width+x]
                else:
                    height_top = 0.0

                if y > 0:
                    height_bottom = heights[(y-1)*width+x]
                else:
                    height_bottom = 0.0

                if x < (width-1):
                    height_right = heights[y*width+x+1]
                else:
                    height_right = 0.0

                if x > 0:
                    height_left = heights[y*width+x-1]
                else:
                    height_left = 0.0

                baseindex = y*width+x
                height_this = heights[baseindex]

                #Calculate and store the new height
                heights[y*width+x] = (height_this + (height_top + gradient_u[baseindex]) + (height_bottom + gradient_d[baseindex]) + (height_left + gradient_l[baseindex]) + (height_right + gradient_r[baseindex])) / 5

    normalize(heights, width, height)

    print("Storing Bump...")
    for x in range(0,width):
        for y in range(0,height):
            pixels[(y*width+x)*4+3] = heights[y*width+x]

    # Generate Red with radius 1
    curviness = generate_curviness(heights, width, height, 1)
    normalize(curviness, width, height)
    print("Storing Curviness...")
    for x in range(0,width):
        for y in range(0,height):
            pixels[(y*width+x)*4+0] = curviness[y*width+x]

    # Generate Green with radius 5
    curviness = generate_curviness(heights, width, height, 5)
    normalize(curviness, width, height)
    print("Storing Curviness...")
    for x in range(0,width):
        for y in range(0,height):
            pixels[(y*width+x)*4+1] = curviness[y*width+x]

    # Generate Blue with radius 25
    curviness = generate_curviness(heights, width, height, 25)
    normalize(curviness, width, height)
    print("Storing Curviness...")
    for x in range(0,width):
        for y in range(0,height):
            pixels[(y*width+x)*4+2] = curviness[y*width+x]

    print("Storing image...")
    new_image = bpy.data.images.new(new_image_name, width=width, height=height)
    new_image.pixels = pixels[:]
    new_image.update()
    new_image.pack(as_png=True)
    new_image.use_fake_user = True

    print("Done")

for img in bpy.data.images:
    if "_nmp" in img.name or ".nmp" in img.name:
        new_img_name = img.name
        new_img_name = new_img_name.replace('nmp', 'bump')
        print("%s -> %s" % (img.name, new_img_name))
        process_image(img.name, new_img_name)

The script will look for all images with '_nmp' or '.nmp' in the name and will generate an image of the same name, but with 'nmp' replaced with 'bump'. Each generated image will consist of 4 channels (RGBA). The Alpha channel will be a bump map generated from the normals, while the Red, Green and Blue channels are each a Curvature map - one with a radius of 1 pixels (Red channel), one with a radius of 5 pixels (Green channel) and one with a radius of 25 pixels. The curvature is measured only in the Horizontal and Vertical directions but the result seem reasonable to my eye (I've not got much experience of curvature maps - if there's a problem with these then let me know and I can update the calculations).
Here's the normal map (a section of the map from your question) :

Here's the result :

Bottom-right is the generated bump map, Bottom-left is the red channel (1 pixel radius curvature), top-right is the green channel (5 pixel radius curvature), top-left if the blue channel (25 pixel radius curvature).
The way this works is to first process the normals from the normal map to determine the horizontal and vertical gradients at each point. These are re-normalized to correct for any inaccuracies (such as 8-bit encoding) and extreme values are clipped to avoid problems before being averaged with its neighbours to get a gradient between those pixels. These gradients are then used to determine the difference in height between neighbouring pixels and those height differences built up into the bump map (this is the part that takes the time).
The resulting bump map is stored in the alpha channel and is then sampled to determine the curvature at each point, storing each in the R,G,B channels.
The script produces output of progress to the console - so run Blender from the command line to view the output. Beware large normal maps taking a considerable amount of time to process - on my system the full 2048x2048 map was estimates to take around 10 hours to complete so I used a cut down section for my testing (604x408 pixels) - which only took a few minutes to complete.
EDIT :
Just to clarify, the script takes the original Normal Map...
'rock5_nmp_clipped'

... and extracts the height information into a bump map with the same name but with 'nmp' replaced with 'bump'...
'rock5_bump_clipped'

...along with 3 separate channels, each with the curviness map calculated at different radii :

To analyse curvature using a different radius simply amend the calls to the 'generate_curviness(...)' function and re-run the script to generate a new image :
#Use radius of 25
curviness = generate_curviness(heights, width, height, 25)

e.g., change to :
#Use radius of 40
curviness = generate_curviness(heights, width, height, 40)

Using the Normal Map

The curviness stored in the R,G,B channels of the generated bump map can be used to add wear or additional effects :

Since we now have the actual underlying 'bump' information we can use this to drive other effects - such as the True Displacement - generating a much more realistic surface :

(Above example rendered using a single plane, subdivided to 256x256 faces and displaced with True Displacement (see displacement properties panel at bottom-right of image). All depth, displacement, and wear derived from original normal map, extracted by script.)

Updated answer with enhanced script to process a normal map and generate the bump map along with curvature maps at different radii. Hope this is of some use.

Hi, could you share the node setup too so we can understand what the script does visually and see every steps?

Updated answer - hopefully this makes sense. Important to use Non-Color Data in the Image nodes, then just split into channels using Separate. Let me know if still not clear.

Hi. thank you for your explanation. How do i extract the height information? Can i do that using a node?

@DanylBekhoucha The height is simply the Alpha channel of the image - ie, the Alpha socket of the Image Texture node. In te last image you’ll see that it feeds into the Multiply node. The ‘height’ will range from 0 for the ‘lowest’ point to ‘1’ for the highest point. In the example the Multiply node is just to scale that range to allow the displacement to be adjusted.

The Alpha of my normal map is white.

It’s the Alpha of the generated image you need to be using. Te script takes your ‘nmp’ file and creates a new image with a similar name (replacing ‘nmp’ in the filename with ‘bump’ - the script will only process images with ‘nmp’ in the name). It leaves your original image untouched. When you ran it did it create any images? Did it produce any output to the console? How long did it take to run? (If it finished instantly then it’s a sign it didn’t find anything to do)

In https://i.sstatic.net/858r7.png you’ll see that there are two inage nodes - ones the ‘original’ and the other is the one generated by the script.

@Rich Sedman, the results from your script are quite good.. perhaps would be better to use numpy in it as it makes it a lot faster to calculate.

Thanks @Secrop - I’ll take a look at numpy. I’m sure there are other changes I could make to make the generation of the bump map much quicker too.

I did a node setup that produces a nice result, but I don't consider it a perfect solution. It won't give the same results as other softwares (thought other softs also produce different results). The kernel function I used is very simple and basic, and while the best approach would be sampling a wide area, this kernel only samples two directions, and uses gaussian blurs to approximate the rest of the kernel range.

Nice result! Also you should convert the image in Linear mode in the "n" menu and use Mix Overlay nodes instead of math multiply to keep the same grey level. Then at the end add a gamma 2.2 node.
And you should use relative blur to make it work with every resolution. You can take the high quality 2k here: https://drive.google.com/file/d/0B1wP1Y8dmh8aVmN6VUpYMU02Q28/view?usp=sharing
And even your sharp effect is really good too, we can clearly see the reliefs. Thank you a lot for trying to help making this effect!

@DanylBekhoucha,  as I said, the kernel is basic. I would like to do a good kernel for this but I'm afraid that will take much more than 20min in the composer. Perhaps in another time I will write an operator just for this.


text:
Lightning Glow not Rendering
I am trying to render lightning to my scene, but for some reason on the viewer the "glow" shows up (left pic), but after I render the glow completely disappears and looks completely flat.
I have no idea why this is happening...

Figured it out! You need to add a glare node in order for it to show up in the final render!

Please clarify your specific problem or provide additional details to highlight exactly what you need. As it's currently written, it's hard to tell exactly what you're asking.


text:
Following a video and when using the array my fans are in all diferent Z positions
I'm sorry i'm very new to blender but I'm trying to make a CPU cooler and in the video his array goes nicely around the cylinder but for me the fans go in a different position and i'm not sure how to fix this

Hello, you must make sure that the empty that you are using as array Object is set at the exact same point as the fan origin, alos apply its scale

If moonroots comment doesn’t help, pls provide blend file. We can help

@moonboots: is "alos" french and means something like "allons-y"? :D

you shouldn't say sorry, that you are a beginner. we all started one day. But it is an important information, so i would always add it to the question so that the one who answer know how detailed the answer should be ;)

@Chris, you say "If moonroots comment doesn’t help", how dare you?!??

and "alos" is a very mean insult in french that i can't translate

@moonboots: i can dare because i am not afraid of being killed by superman. It's a quick pain free death...so that's ok ;)

i knew you aren't as nice as you pretend to be....!!!!!! :D :D

@moonboots that did it ! the fans are now in the correct place, thank you

@Chris Thank you for offering help as well appreciate it :)

you are welcome!

by the way, mooonboots, what happened?! are u chilling? [1]: https://i.sstatic.net/K4yEf.png

@Chris I can't hurt you, you have kryptonite. About my score, you need to know that I'm the one who gave you most of your reputation points (I gave you 4000 this january, don't know the one who gave you 39)

@moonboots: thank you sooooo much. You are too generous to me!!!! I wondered myself where i got those points from too....i tried to downvote you as much as i can...but as soon as i tried to click it...i got hit by a flash and couldn't move for hours....!!!

so you're the one who downvote me...   :/  i'm so disapointed... btw, I've subscribed 620 times to your youtube chanel, I guess the 621th is yourself, now I think I'm going to unsubscribe...

You must make sure that the empty that you are using as array Object is set at the exact same point as the fan origin, also apply the object scale.

i pressed downvote....and woooahaaa..you got +1 again! how do you do this!?

it's a little python script that only gandalf and i know

i suspect it's the way he got 150 000 points by the way

gandalf is....your father? :S

LOOOOOOOOOOOOOOL

i don't know, he's a guy who thinks he's smart

he has 151K.... ;) (oh man, Marty and Gordon's behaviour is coming over me....) :(

yes, 151k with very lazy answers

he is gandalf3 - maybe just continuing his fathers and grandfathers account.... ;) so gandalf2 and gandalf1


text:
I'm having trouble with gizmo lines getting glicht: rotating, moving or scaling
System:
Windows 10 64 bit
CPU
I5-3470
GPU
GT 630
Processor and Graphics do not matter because the same thing happens on different Graphics and Processor
I found a fix but on ubunto I have windows

I fixed it by just removing the blender foundation folder from %appdata%

Another user reported on Blender chat that fully removing and reinstalling Blender fixed the same or very similar issue.

Another user on Blender chat reported deleting %appdata%\Blender Foundation\ worked like KALER suggested.


text:
Kickflip animation
I'm new to Blender. I'm trying to animate a kickflip. Reference video
If the skateboard stays horizontal no problem I can rotate it around its long axis (Y), but if I want to add a flying curve to it its make a weird rotation. I kinda understand why is it happening and why my first idea wasn't successful but unable to find out how to solve this problem.

Blend file: skateboard.blend

hello, in what way is it weird?

Moving out on the global X axis. It should only rotate around its Y axis

maybe parent it to an empty, so that you can make the skate rotate on itself and also tilt the empty the way you want?

The pivot point for the rotation is at the back. This makes the nose of the board spiral up and down in an unnatural way when the board rotates around itself and rises. Also, the up and down motion seems to be linear. It should go forward & down in a parable not in a line.

@Edgel3D I like the bounce of this "ghost rider skateboard" at the end :-)

@Blunder ,  I must have a 'thing' about bouncing.  I even do it with rope!

In your animation, the pivot point for the rotation is at the back wheel of the board. This makes the nose of the board spiral up and down in an unnatural way when the board rotates around itself.
Also, the up and down motion seems to be linear. It should go forward & down in a parable, not in a linear way.
I would make a little rig then you can rotate the board around three pivot points... like so, and so, and so, and this way, and so, ...

Just make sure you have set the bone roll values correctly. I had forgotten about it in the animation above.
The rig has a bone chain with 3 bones.

Back Wheel bone, it's the root and placed from the back wheel to the front wheel
Front Wheel bone, it's a child of the Back Wheel bone and goes from the front to the back wheel
Board Rotation bone, a child of the Front Wheel bone but with offset (unconnected). It's placed in the center of the board.
the skateboard object is parented to the Board Rotation bone. (In Pose mode, you need to select the skateboard object and the bone, and press Ctrl+P > To Bone)

In the side panel (N-panel) you can lock the location and the scale with the padlocks so you cannot accidentally move the Board Rotation bone.
For the Back Wheel and Front Wheel bones, you can lock the rotation around the Y-axis.

Test animation

Does it seem to float a bit at the peak? It surprised me that you can make the skateboard stop, jump, and move forward again as shown in the reference video.

Thanks for your help. Not really understand (yet) what I was doing with the bones, but made it work.


text:
Is it possible to have the Knife tool cut non-straight lines?
Beginner user of Blender here. Would it be possible to have the Knife Tool draw unstraight lines similar to the Annotation Tool..? Basically, what I want to do is to try and cut out a part of an object and leave the edges smooth but the Knife always cuts in straight lines.
(apologies for the poor wording)

Hi :). No that's not possible, Knife tool only cuts straight edges. You can use Knife project with a curve to get a more 'smooth' result.

@JachymMichal: well, if use the knife tool, zoom in a lot and click a lot - you can do non-straight lines :D

@Chris true dat :D

https://blender.stackexchange.com/questions/50538/how-to-cut-an-object-along-a-curve/50560#50560

Alright thanks for the suggestions


text:
Getting this "large mesh" that cannot be removed after a boolen union. What is it?
I'm using Blender 3.6 and did boolean union on a few objects. I got the result I wanted, but there are some areas that are "shadowed". When I hide the shadowed meshes (like the ones pointed by yellow arrows), it reveals a big mesh underneath and somehow, I can't select/edit that mesh. What is it? Is there a way to clean it?


text:
Looking for a good workflow for re-texturing and re-creating UV
I'm not familiar with Blender or 3D in general. So, I'll explain what I want to do with pictures. So, I have this model below:

It comes with a color texture and UV map:

So, that looks bad. I want to fix it. Make it look something like this:

So, I get that far. But I can't make the texture to follow the new UV map.  I'm guessing I skipped several steps in my workflow. Any tips on how to fix this?
Thanks.

Research "baking".

If you want to remap an image texture you can bake it using 2 different UV maps.

(1) In the UV Maps list, make sure the source UV map ("UVMap") has the "camera" icon activated. This one is used for rendering. The other one ("New UVMap") is selected. It's the active UV map and is used for baking.
(2) In the Shader Editor, connect the Image Texture node to an Emission node and this one to the Material Output node. (You can omit the Emission node, then Blender will use one internally.).
(3) Add a new Image Texture node, and create an image for it with the little button in it. Make sure the Image Texture node is selected (white border) to tell Blender that this is the bake target.
(4) In the Render Properties tab switch the render engine to Cycles. Adjust the number of max samples and check the Denoise option if you like. (Since version 3.0, Blender can now denoise baked images). Select the Emit bake type. Hit the Bake button and check the result in the Image Editor.
(5) Important: Don't forget to save the image if you're happy with the result. There is a hint in the status bar. Images must be saved individually because they won't get saved if you save the blend file, close Blender, or when Blender crashes. Possible data loss!

Thanks. I actually tried this before and kept getting a black image, tried multiple solutions offered by googling and went nowhere. But at least, it gave me some hints and figured out how to do it with Eevee.

You're welcome. I wonder how you did that with Eevee, because you can only bake textures with Cycles. If the result is black, this could be due to a value greater than 0 for the Metallic or Subsurface Scattering settings of the Principled BSDF node.

I'm not quite sure. Maybe it's not really Eevee. It's some youtube instruction about PBR texture. I just remember that Eevee render engine was selected, not Cycles.


text:
Differences between Principled and Beckman Glass BSDF
Comparing Cycles renders of a glass bowl, I see a color shift and an angle shift when switching between Principled BSDF shader and Glass BSDF (Beckman) shader.

Is anyone aware of other differences?

Note: according to Is the Glass BSDF shader in Blender PBR accurate?, the Principled BSDF is more accurate.
Details
Blender 2.79 RC2 2017-08-18, hash 7b397cdfc81
Pro Lighting: Skies (Demo) Cloudy 08
Color of the bowl: e7c8b0
The bowl is sitting on a polished slab. I originally used the Glass BSDF shader with color e7c8b0, and otherwise all default options including Beckman model. Originally, there were a pair of undesirable reflections:
1: Light reflected off the polished slab, then reflected off the bowl and into the camera.
2: Plus a tertiary spot due to the reflection off the slab, then off the bowl, then off the slab into the camera.
I considered these "undesirable" because they were in a location that detracted from the feel I wanted, and because they were surrounded by rectangular artifacts. They looked like mistakes. I eliminated them by moving the bowl closer to the edge of the slab so that the primary reflection was off the edge and thus none of the secondary reflections appeared.
When I switched the shader for the glass bowl from Glass BSDF (Beckman) to Principled BSDF (roughness:0, transmission: 1.0, base color: e7c8b0), it appears that incident angles are calculated differently so the primary reflection is no longer off the edge of the slab and the undesirable secondary reflections have reappeared. The fact that the primary reflection is in a different location is not necessarily a problem in Principled BSDF. I do not know which shader is more accurately modeling angles.
The Glass BSDF looks slightly muddier and browner than I expected based on the color I assigned the glass. The Principled BSDF looks closer to what I expected, and the reflections look cleaner and closer to the colors in the IBL image.
I would be happy to upload the non-cropped images and the blend file, but I am new to Blender and don't have reputation to add that many links to a question. If full images and blend file would be helpful, please suggest a location/path for me to upload them.
Update
The rectangular artifacts around the reflections turned out to be coming from the Denoiser. I really like the Denoiser otherwise.

What is the goal of your post, do you like an aswer such as yes we are aware ?, who needs to be aware, this no question neither this a blog site for personal experiences.


text:
Metaball-style merge effect on two modelled and realistically textured human heads possible?
I would like to create a complex animation in which two rigged objects - human head models in this case - merge together as they float next to each other with a similar effect that metaballs have on each other.
Is this possible in any way? I'm trying to find the best way for the skin to pull out from the parallel side of each head and have them merge (With the merged skin materials being seamless), similar to a metaball interaction but with a detailed skin material. The only example I can think of which is along the lines of what I'm aiming for is the split-face scene in The Thing (2011) (Very graphic) at the 2:20 mark. (I'm not aiming for this much realism of course.)
Like that but with the heads floating and magnetized to one another. I'm also hoping to have the faces animated on their own before the merging/smashing together takes place so they'll be rigged but this question is only regarding the mesh & material merging effect specifically.
As far as I know, you can't model and animate metaballs with as much detail and variation that a human face requires or convert part of a mesh into a meta object so would this work by keyframing the skin meshes towards each other in a stretching fashion then merging them into one mesh at the desired frame?

Combining the meshes with the Boolean modifier and then smoothing out the result is an idea worth exploring. Example:

Settings:

If the two faces have very different shapes, you could use a shape key to morph both faces into something in between, so that they blend more nicely.
You can also use additional boolean modifiers if you want to ensure that the merging faces don't pass "through" each other (i.e. if you don't want the moving monkey's right ear to be visible near the end of the animation, you could "mask" it out with another Boolean intersection modifier).

keyframing the skin meshes towards each other in a stretching fashion

You can also add various distorting modifiers before the boolean merge to achieve the magnetic stretching effect you describe (e.g. with a Lattice modifier or similar).
Challenges
While the basics of this technique are easy to implement, you might run into difficulties if you want a more complex animation:

This technique forces you to use a smoothing modifier, which might be undesirable. However, you could fade it in as part of the effect and fade it out when the animation is complete.
The faces need to be single, non-self-intersecting objects. This means that you would most likely have to deal with other components, such as eyes, individually. (In the example above, I modified the Suzanne model so that the eyes are connected components).
UV texture coordinates will be unusable due to the boolean modifier. I can suggest either texturing your model procedurally, or rendering another version of the animation with textures, but without the merging effect and then combining these two renders during compositing.

Also consider: Data Transfer to build a vertex group for confining the smoothed region, and voxel Remesh for either making nicer geometry for the Smooth, generating manifold inputs for the Booleans, or replacing the Booleans.

Also, Shrinkwrap to pre-conform object to the join area if there's a perdictable profile in that region.

i would say you'd use the metaballs movement as a shape key, copy the animation to a mesh, and use that animation for the two textured heads.

Hi, thanks for the post. This site is not a regular forum, answers should be substantial and thoroughly explain the solution and required workflow. One liners and short tips rarely make for a good answer. If you can [edit] your post and provide some more details about the procedure and why it works feel free to restore it, otherwise it may be deleted or converted into a comment. Perhaps add a few images illustrating the workflow and final results. See How do I write a good answer?


text:
How To Render Glass Materials in Cycles
First: After modeling, I render the Object in Blender, it was fine to me or in my eyes. See the Image.

Second: I tried to render the Object in Cycles since the Glass Material which I downloaded from the internet was made for Cycles. It's not fine to me or to anyone at all. There is no light, and the worst is the Glass Material didn't apply to the Object. See the image below.

Finally: The image below is the Settings in the Material Box. So, how to make it to be like the first image (that is the glass material) rendered in Blender, to be able to work in Cycles?

In the bottom image you posted, there's a box that says "Viewport Alpha" which is set to Opaque. What happens if you change it from opaque to something else?

I have tried all such as, Alpha Anti-Aliasing, Alpha Sort, Alpha Blend, Alpha Clip, Add, then Opaque ; they are with the same result.

I'm not sure about the downloaded pack you are using, but blender has a built-in Glass BSDF shader that is meant for cycles (I'm assuming you're using 2.79 - I think it should be there). Just click the "use nodes" button, split your view so you can make one window a shader graph, add a Glass shader Node, and connect it to the material output.

Related Q's about glass... this question and  How can I make a more realistic glass shader?

Alright, @ Christopher Bennett; I have done that, but the glass material is darker also looks too tick, rather than light as it in the Blender Render. I will try to work on it, then if unsuccessful, I will post my difficulty again. Here I downloaded the Glass Material [link] http://blendermada.com/materials/detail/79-clear-glass-material/

Oh, @ChristopherBennett just now I viewed properly at the link I sent you where I downloaded the Glass Material to find out that it was truly meant for Blender Internal but others were for Cycles Render. Could it be the reason why it rendered aptly in Blender and giving me headache in Cycles? I hope I'm not mistaken or complicating both?

@Timaroberts, I have bookmarked the link you sent me, I will make time to study it, but using already made seemed to be saving time, which was my reason to grab those materials from the net.

Yeah, sorry. I'm not familiar at all with the material pack you have, and it's been quite some time since I used blender internal. I'm not sure how else to really help. Maybe try mixing a Transparent or Translucent shader with a Glossy and then adjusting the roughness to get that "plastic" look That's all I can really think of at the moment.

@FrankfortStainlesscoin   this Q might be useful to have a look at to understand some of the differences between the two engines, materials are fundamentally different. Now that internal has been removed, you will be better to learn cycles.

@ChristopherBennett, yeah I will try to play around with your last suggestions. Then I will post the final result whenever I finish the modeling, (if I will remember the promise).

@Timaroberts, The same in my hitherto assertion, 'bookmarked...'I wanted to send greetings but we weren't allowed to do so. But in everything everyone who helped another understands that while lecturing others, he is learning likewise.


text:
Cannot make rest position as pose position
I have an animation that starts with a weird pose. I want to insert a neutral/rest pose into frame 0. Based on several previous answers, I did the Alt-G, Alt-R, and Alt-S. I also have no bone constraint. It did reset the pose. But after I scrubbed the timeline back and forth, it went back to the old weird position. Is there anything else I should do. This is Blender 3.6. Thanks.

You did reset the pose - but did you save that with keyframes for all bones on frame 0? When the "weird pose" is keyframed on frame 0 (as you can see in the timeline), just resetting it will not change a lot, that is just temporary when keyframes exist. As soon as you move through the timeline, Blender will read the keyframed positions again. Are you familiar with keyframed animations?

Mixamo animations are baked. They have keyframes for every single frame. If you want to combine or mix poses & animations, have a look at the NLA editor.

I moved the entire animation about 15 frames to the right and inserted 2 new keyframes at position 0 and 10. So, those are baked too?

hello could you please share your file?

Sure. A couple more info. I did a retarget animation (using autorig) to a mixamo default t-pose model I downloaded (not a mixamo animation). Here's the google drive link. https://drive.google.com/file/d/1yl3pf1br58XXlt_hVuhCiZa-JkQIiWWz/view?usp=sharing

If I go to frame 0, reset the pose with Alt R, Alt S and Alt G, then press i to insert the keyframes, it works fine, so I'm not sure what's your problem?

So, after you insert a keyframe at frame 0, you're able to apply t-pose like my screenshot 2, and when you scrub left-right, the t-pose pose stays?

Yes look: https://zupimages.net/up/24/27/5kfu.gif

I guess I'm blind. Can you tell me what I missed from this video? The keyframe selections look a bit different than your capture. I played around a bit with that and nothing worked. I also updated my blender from 3.6.5 to the latest 3.6.13 last night. It didn't help either. https://imgur.com/a/ELjJh1g

do you press "i" once you've reset the pose? also are you sure that you have the correct keying setup (if you use the latest version of Blender)?

I knew it's something simple. Pressing "I" solved the issue. Thanks.

You have just forgotten to press i to insert the keyframes


text:
Is there a faster way to merge edges together?
I have been dragging individual vertices from the outer edges in to the inner edge and merging them. There must be a faster way to sort of collapse the outer edges in to the inner edges. I will be working on more complex shapes and doing it like this is gonna take a lot of time. Hoping there is a faster way. Below on the bottom right of the image, you can see what I am trying to do. Taper it from the bottom till sharp on the inner edge. I need to do this all the way round.

Can't you choose another way around? Keep only one edge, extrude up:

Select all and press AltE > Extrude Faces Along Normals to give it thickness:

Select the top edge ring, press X > Collapse Edges and Faces:

Here is what it gives:

This is very close to what I need but I need the edge to collapse towards the inner edge and not collapse to the middle. Is there an extra step that can be done to easily align the top vertices to the inner edge vertices of the bottom after this?

I have figured it out myself and discovered edge slide! Thank you for your help.

oh yes edge slide is even simpler

You'll then need to merge vertices by distance after the edge slide if the two edges are on top of each other.

or just enable the Snap and Auto Merge options


text:
How can I change the pose of a 3D model I download?
For example if I were to download the following file: https://cults3d.com/en/3d-model/various/serpent-kodoku
How can I straighten the model out or put it in a different pose which I will then later 3D print?

hello, if this model is free, please share so that we can take a look: https://pasteall.org/blend/

That was just an example model. I am asking in general with any 3D models what would be the best and easiest way to change the pose of an existing 3D model that is already in a pose.

each case is different, so there is not one unique solution for all the cases, it may be with armature, of with the Pose brush in Sculpt mode, etc... as for your snake it seems rather complicated to make a cylinder from a spiral, maybe someone has the answer


text:
Add automatic nodes? Blender does not recognize materials in this format
When I import a .smd file to blender (yes, it's a addon), the textures are not rendered, it's like the material is not applied and I need to add 1 node for each texture and it's too much work.. is there another way?

with other formats, for example .obj, it is not necessary to add nodes, blender perfectly recognizes the textures

I made a script for this exact purpose. Here it is on GitHub, along with one for fixing the armatures. https://github.com/thelabcat/SMD-Model-PostImport

How exactly does it work? I have added the script, added the folder path and run it, but I don't see the changes :(
https://media.discordapp.net/attachments/472521435676672010/939964215190487101/Captura.JPG?width=775&height=566

Did you follow the instructions written out in the script?

Yes, I added my directory to the MAT_PATH, as in the example. I do not understand the function of NAME_SIZE, my files do not have any character of type '_'

Yeah, not all Source games work quite the same way. Most of the files I was working with were from sonic generations. You can get some of those models from models-resource.com if you want to see what kind of file names I was working with. Name size is a component of the function that is meant to identify whether an image is related to a material or not. Modify that function as necessary.


text:
control shape Key with bones local distance to specific vector?
I want to control a shape key with a driver that is controlled by a bone. The bone should have lets call it a "goalVector" in its local space for example [0.5,0.5,0.5] from its local [0.0,0.0,0.0] "rootVector".
If the distance from the "rootVector" to the "goalVector" is shortened, the driver should be activated. Just like a distance driver but without a seperate object and with just a distance set from the bones local "rootVector".
Is there any way to handle this with expressions?

While it's possible to do this with drivers, without an extra object, you need three driven properties, XY and Z, to do it, and so the whole thing gets unwieldy.  You can do it with extra objects-- well, extra bones-- very easily in comparison.  Is there some reason you don't want to make some extra, hidden mechanism bones instead?

I was already trying this, but I dont get how to get the distance from one bone to the other. Cause either they are in local space so they are each in 0.0.0 or they are in world space and the distance is only really measurable if at least one bone is centered in the worlds 0.0.0 origin.

If they have the same parent, and the parent is unscaled, world space distance and local space distance is the same thing.  They are not in 0,0,0 in local space if they have been moved-- but it's possible you meant something difference than distance?  Maybe you meant, are they pointing the same way as indicated by the goal vector?  That's not the same thing.

@Nathan
No its just the distance from position A to B that has to be mapped to a range from 0 to 1 for the shape key.
Anyways, thank you :) for now I will try it with some distance bones, but perhaps there is a way to do this with values, because if the bone goes farther than the distance bone, the value will also shrink again. Not sure if there is a possible and clean way to go around this.

Okay, that doesn't sound like what I'd call "local space", so that's going to confuse any answers.  And, yes, moving it in a line through goal will mean that the shapekey reaches distance 0 and then increases distance, but I'm not sure what you'd like to happen instead-- if you're not increasing distance afterwards, you're not using distance.  Maybe you should take a step back and talk about the original problem you're trying to solve, for which you feel this is a solution?


text:
Python Centering Mouse X Y Coordinates To Operator
I am trying to get familiar with the modal operators in blender and want to create some kind of custom trackball rotation.
When I set the rotation euler values to the mouse_x and mouse_y event values, blender adds the absolute mouse position to the rotation values.
Is there a possibility to start with 0 when I click the operator button?
def execute(self, context):
    bpy.data.objects["Cube"].rotation_euler[0] = math.radians(self.value_z)
    bpy.data.objects["Cube"].rotation_euler[2] = math.radians(self.value_x)
    return {'FINISHED'}

def modal(self, context, event):

    if event.type == 'MOUSEMOVE':  # Apply
        self.value_x = event.mouse_region_x
        self.value_z = event.mouse_region_y
        self.execute(context)

Just store the last ones and subtract them. See: Text Editor > Templates > Python > Operator Modal View 3D

Thank you it worked :)


text:
How to do an Emboss effect in Blender?
How can I create an emboss effect in Blender and set the angle and height. This node doesn't exist in Blender.
This effect is popular to convert a normal map into a curvature map.

Creation of the emboss filter effect
Blender has no emboss effect node, you have to recreate it, hopefully this effect will be available in the future into one node.
An emboss effect basically duplicates an image in two directions defined by an angle direction, one of the two images has his colors inverted. From 0/(-)180 the direction is only horizontal, from 90/-90 it is noly vertical. If the angle is set to the left with for example 95 the horizontal images are inverted, if it's at the bottom like -20 the vertical images are inverted.

The emboss takes three inputs:

the image on which to perform the emboss
the angle, it's the direction of the emboss
the height, it's how strong the image are separated

To better understand how the angle works, it will define a multiplier for the X and Y direction:

Angle at 90: it sets a multiplier at X: 0*height and Y: 1*height so the images won't move horizontally
Angle at -90: 0*height and Y: -1* height, the vertical images will be inverted
Angle at 45: X: 0.5*height and Y: 0.5*height
Angle at *-45: X: 0.5*height and Y: -0.5*height, the vertical images are inverted but not the horizontal because the angle is at the bottom right and not bottom left.

So here is the node setup to achieve the emboss effect, you can download the node setup here: https://drive.google.com/file/d/18BIzLtwe_27HdtuB2ZZ_lfYCcq3Ym4Qv/view?usp=sharing

The node setup starts the three inputs above. The image is set in black and white and one is inverted.
For the Angle it is converted into a radians in order to works for the value is multiplied by Pi: 3.14159265359 then divided by 180. To define the direction multiplier the X value uses Cosine (the second value doesn't matter, it has no effect) and the Y value uses Sine.
The height is divided by two, because to have a separation of 50 pixels for example you need to move at 25 pixels in each direction. The value is multiplied by the direction multiplier then the X is plugged to the X input of a Translate or Transform node and the Y to the Y input.
The non-inverted image colors must have is translation values inverted and for the inverted image colors the translation values aren't inverted.
In the node setup above the top translation has the image inverted and the bottom has the values inverted.
Finally both images are combined with a Mix or Value node at 0.5.
A Gamma node at 2.2 can be added after it to convert the image in Linear like the generated emboss effect of Photoshop. Keep it in sRGB (without the gamma node) to work on it with gradient colors or to overlay it.
What can you do with the Emboss effects?
Almost every game artists use the Emboss to generate a curvature map from a normal map.
On a normal map the Red channel creates lighting coming from the right, so with an emboss at 0 degree and height generally of 1 to have 1 pixel width (Substance Painter's curvature use an height of 8) overlayed with the green channel with an angle at 90 degrees and the same height as the red you can generate a curvature map. Don't forget to set your normal as Linear in the "n" menu to convert the image in sRGB to get a correct result:

Additional informations:

Normal to curvature map (a quicker way to generate it without doing the emboss math nodes): https://blender.stackexchange.com/a/72602/23134
Normal to curvature smooth map: https://blender.stackexchange.com/a/100637/23134
Fake hand painted texture: https://blender.stackexchange.com/a/90153/23134


text:
How can i add specularity, shadows and decals on top of a Blender Cycles bake
I want to improve my Blender cycles baking by adding specularity and shadows to make it "partially real time" and decals while keeping the lighting informations.

Switch to Blender Render or Blender Game, import your baked texture and set the emit to 1.0 to get the full lighting information. Optionally you can then import a roughness texture and set it as specular color to create some effects on the surfaces.
Add point light where light are coming from, inside a room add them on each window. Change the color to match the color of the exterior (sky, green garden, other room). Uncheck Diffuse so it will not emit light and leave the Specular checker.
Now adjust the specular intensity of your material and the hardness.

For the shadow add a sun, keep the same sun orientation that you had used for the Cycles baking and enable shadow, check Only Shadow but keep the Diffuse and Specular checked. Adjust the light intensity to contrast the shadows, set the Buffer Type to variance (to get smooth shadow borders) and adjust the settings. Use the Shadow Box to only include your level to maximize the performances or parent it to the camera and reduce the shadow box so you get shadows on close objects only.
For decays add a new texture completely transparent, you can use an high resolution, then paint or project images on your 3D model using the stencil mode. Blend the image in Multiply mode to keep the lighting informations.

You can then add post-processing filter like Bloom in the logic editor.


text:
How can i use Filmic with Blender Cycles baking
I want to bake my lighting or light map with Filmic but when i change the color management to Filmic (Blender 2.79+) it has no effect.

You can't bake directly with Filmic but you can composite the texture baked.
Baking with Filmic
Warning: before baking check if:

GPU baking is enabled
check if the normals are correct, to bake an interior scene the faces need to be oriented inward
for your materials use the Diffuse and Emissive shaders only, the materials should not have reflections. Color texture and normal map can be used but you will loose their quality
unfold the UVs, you can do a Smart UV Project if it is an interior bake with a margin of 0.05 to hide the seams

Baking steps:

you must first create an image using 32 bit Float, this will allow to save values higher than 1 (this is the most important part, if you don't create the image correctly you will need to rebake everything)
assign the texture for every shaders used by the baked mesh, make sure it's the active image by selecting it if you have multiple textures
bake the lighting
import the image in the compositor and plug it to the Composite node
change your render resolution to match your image, don't forget to set the percentage to 100 %
in the Scene tab in the property panel, change the Color Management setting to Filmic instead of Default and you can eventually adjust the contrast in the Look setting by default it's set to None (does the same as Base Contrast)
do a render (F12) and save the new image, I recommend you to use TGA

You can then update your lighting, bake it and press F12 to have your new lightmap.
Do it for every bakes including the skybox to keep a consistent lighting and avoid "burned" areas.
Using it in Godot Game Engine
To use it in Godot, export your OBJ and uncheck "Write Material" this will allow to have only one material slot. Export your lightmap as TGA, this format is faster to load than PNG and use RGB instead of RGBA to save some memory.
In Godot select your texture, in the Import tab set the Mode to Loseless and uncheck Filter (it blurs the texture).
Add your .obj into the scene, create your Material, assign the lightmap as Albedo and make sure the color is set to pure white to display the texture correctly otherwise it will appear darker. In Flags check "Unshaded".

While playing if the skybox (the sphere with the sky texture) isn't visible increase the Far setting of the camera. You can set it to 1000 instead of 100.
Project files: https://drive.google.com/file/d/1luU3j60UTCjijg6BC2hOkintSy8vzXSp/view?usp=sharing
How to use it correctly
When using baked textures the size of your game can become heavy, that is why I recommend you to have small and few rooms, like for example a 3D puzzle game like Portal.
If objects have to move or be collected the lighting won't be updated. That is why I suggest you to make them transparent, like holograms, so they fit in the game, like in this fully baked game: https://youtu.be/H-E7_mn73BI
What is the benefit of this technique
Having fully baked lighting allow to have a great looking scene that uses almost no ressources to run, it can run without a graphic card at 60 FPS even on a web browser or a mobile device as long as you don't fill the memory.
Later denoising will be added for Cycles baking allowing to get a better result with less samples.

I still don't understand why you would do this. Isn't it much better to bake your lightmaps as linear, and apply filmic (or any other tonemapping) to the final render, rather than tonemapping the lightmaps.

@JtheNinja Yes, if you're planning on rendering in Blender.  But if what you're trying to do is create a texture for use in a different rendering engine, and you've been building the texture using Filmic color management, you may want to do this.

Yes like the comment above me, exporting one or several 32 bit float lightmap(s) in a game engine would waste way too much memory (and I am not sure every game engines allow those textures), it is better to compose it/them in Blender and export the final colors tonemapped in 8 bits.


text:
How to combine the Bevel shader with displacement and bump textures
Edit: the displacement node has been changed in more recent builds, before it was used as a bump effect, now it displaces the geometry by default so you can't reproduce my issue in this post.
I want to combine the new bevel shader with a displacement/bump texture but when I use it the bevel the details are smoothed and becomes invisible:

How can I combine the noise displacement with the bevel shader?

I have removed this sentence, apparently since the latest build the displacement socket displaces the geometry to use it with adaptative subsurf, in the 2.79 it's used as a bump map by default. So his solution of converting it into an height map and using it in the normal input of the bevel works, I mark it as solved.

You can use a Bump node to convert the texture into the required Normal to feed into the Bevel node - rather than using the Displacement socket :

The Bump node takes the height information and generates a Normal and the Bevel node can use this Normal instead of overriding the one generated by the Displacement.

Hi, I have tested with the latest build my node setup and my issue has been fixed, I can see the displacement when I plug it on the displacement socket. I had reported the bug several month ago saying that the bevel should be applied before the displacement and not after and apparently they changed that so it occurs before. My displacement is not smoothed anymore and I can add scratches and noise. So this question is useless now, thanks for trying to help me. I should have tested before featuring it.

Cool - glad it’s resolved. I guess that’s one problem of using the latest features!

Finally your solution works because they have changed the behavior of the displacement in the latest build it can't be used like a bump map but it displaces the model. It's maybe to allow to use adaptative subsurf and micro-polygon displacement more easily. You should post a non-blurred node setup, you can use my image if you want: http://i.imgur.com/9i4TeAY.png


text:
How to delete concave edges automatically?
How can I delete every concave edges from this geometry:

To get this result automatically with only convex edges:

if you dissolve the edge is it not what you want?

The Limited Dissolve by angle will result in a square, it does not detect if it is concave or convex.
Blender generates Convex Hull geometries as collider, so it is capable of detecting that.

Convex Hull operator
There is an operator in the Vertices sub menu (under Mesh) called Convex Hull that

Enclose selected vertice in a convex polygon.

For the proposed mesh the result could be something like this: