I don't think you need any simulation or other visualization than this:

Every straight ray has to go through the focal point, which for a parabola is a single point. You can construct this point for any parabolic solar oven like this [pdf link].

Every ray coming through this focal point will also leave straight up after hitting the opposite side (if the parabola is big enough). The food (or anything else) is supposed to be placed directly at the place of the focal point.

The design with the bottom parabola part under the focal point replaced with (usually) black box is not very efficient if you are trying to heat directly from rays. Usually such design is meant to heat up the whole box, and the food off of this box.

For direct ray focusing a double parabola design with shared focal point will focus the rays much more efficiently:

The pattern of the rays coming through is of doughnut shape, so it is best to place the food in a small circle. You are also able to further focus these rays into a single point with some lens.

If you really need to plot lot of rays, I suggest using CAD software for this (like freeCAD, etc..), where you are able to easily create geometric entities and constrain them to each other.

You can do the same inside Blender with* Constraints* on bones or empties, but it is much more work to setup. The geometry math is very easy though.

You can also preview the caustic pattern of any curved mirrors, but Cycles is not very efficient for this task. Any bi-directional path-tracing renderer is a better choice.

To make cardboard parabolas with Blender you need the Export: Paper Model plugin. You can create parabola meshes with the bundled Add Extra Objects plugin. There are multiple ways to make parabolas, but I like this one:

it is an icosphere mesh Shrink Wrapped to parabolic mesh
it can be disassembled into 5 stackable pieces for easy storage
I marked 1 possibility of gluing flaps placement on one of the pieces, but the Paper Model plugin can figure this out itself. If the cardboard is thick enough, I believe there is no need for flaps, just cuts to be glued together.
it can be sprayed with reflective paint (Mirror Spray Paint cca $5), imho much better choice than gluing aluminium to paper

A popular idea is also to use an umbrella..


The problem is only present in orthographic view. Changing to perspective or a camera view will fix this problem.

It's also why the issue isn't present in the final render, because most of the time you will be rendering with a perspective camera. You can actually zoom into any mesh in orthographic view and small cracks will start to appear on the mesh.

It is a known issue, with the known issue page stating:

  When using Instancing, Motion Blur or Dynamic BVH, self-intersection may occur due to precision issues. Switching to Static BVH may avoid some problems but not all

There are several bug reports mentioning that this might be improved in future here and here


Python script - objects are grey after export to glb file

glTF (GLB) uses a PBR material system, and the Blender exporter requires the exported materials to use the "Principled BSDF" node.  The glTF material system is documented in the Blender Manual.
If the blender_osm addon is producing materials based on the Diffuse node or similar, these won't export correctly in the current version of the glTF exporter.  Your script will need to convert these materials to use Principled BSDF.


Some faces of a model don't respond to UV Mapping

Some of the faces were not selected while assigning the texture.

To avoid that problem, make sure all UV islands are selected when creating or assigning a texture, or select all the UV islands and reassign the texture again from image browser: the small image icon on the bottom of the UV/Image editor window.


3D Manipulator/Origin behaviour issues due to 'Displayer Modifier'

No, there is no variable that allows you to do that.  But what you should look into is the Corrective Shapekeys addon, which basically makes a mesh from your pose for editing, then restores the models original pose when you're done editing.  It's bundled with Blender, you just have to enable it.


How do I set the selected value of an enumproperty?

Ditch the Enum.

AFAIC Using an enum property to list the materials has been superseded by using a pointer property to the ID object type. In this case a material.
Custom search data to UILayout.prop_search
Search custom properties in objects on the scene (Python)
Have used this option here.  Given the property group a material property, which is a pointer to blend material, or None if not set.
An update method on this property sets the objects active material to the sauna specific one chosen.
Added a boolean property to material type to flag (poll)) it as a "Sauna Cloud" material.  The only materials that poll  will have this set as true.
A select menu is drawn by the UI using a UILayout.prop(...) (commented out) or with the ID template.  (Note a custom operator to  add material can be set here, I took out the generic add material_)
Other alterations.
Drew the context objects material slots in the  panel and an option to add a new one. Further to this would be to define your own UIList to add the "Is sauna material" checkbox in the list, add a filter etc.
Displayed the is sauna material checkbox, in panel and prepended it to Material Preview panel, by way of example.
Set the context members material (context.material  only exists in the PROPERTIES area, otherwise needs to be set for material operators) which can used in your addons custom operators, with buttons in this layout,  as
mat = context.material
sc_mat = context.sauna_cloud_material

or in hindsight  sc = context.sauna_cloud.
Changed the namespace from SC to SAUNA and would go as far as to say even SAUNA_CLOUD  The naming convention,  _PT_ for panel type.  is all about limiting name clashes.
import bpy
from bpy.props import PointerProperty, BoolProperty
from bpy.types import PropertyGroup

class SaunaCloudPanel:
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = "Sauna"
    @classmethod
    def poll(cls, context):
        ao = context.active_object
        return ao and ao.type == 'MESH'

class SAUNA_PT_Wall(SaunaCloudPanel, bpy.types.Panel):
    bl_idname = "SAUNA_PT_Wall"
    bl_label = "Wall"

    def draw(self, context):

        layout = self.layout
        sc = context.scene.saunacloud
        ob = context.active_object
        mat = ob.active_material
        layout.context_pointer_set("material", mat)
        layout.context_pointer_set("sauna_cloud_material", sc.material)
        box = layout.box()
        box.prop(ob, "name")
        col = box.column()
        col.template_list("MATERIAL_UL_matslots", "", ob, "material_slots", ob, "active_material_index", rows=5)
        col.operator("object.material_slot_add")
        if mat:
            col.prop(mat, "is_sauna_cloud")

        #col.prop(sc,  'material', text=getattr(sc.material, "name", "None"))
        col.template_ID(sc, "material")

class SAUNA_Global_Props(PropertyGroup):
    def poll_material(self, material):
        return material.is_sauna_cloud

    def update_material(self, context):
        scene = self.id_data
        sc = self
        ob = context.object
        mat = self.material
        # debug print
        print(f"Update object: {ob.name} with material: {mat.name}")
        ob.active_material = mat

    material : PointerProperty(
        type=bpy.types.Material,
        poll=poll_material,
        update=update_material,
        )

classes = (
            SAUNA_Global_Props,
            SAUNA_PT_Wall,
        )

def draw_sc_material_checkbox(self, context):
    mat = getattr(context, "material", None)
    self.layout.label(text=mat.name if mat else "None")
    if mat:
        self.layout.prop(mat, "is_sauna_cloud")

def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.saunacloud = bpy.props.PointerProperty(type=SAUNA_Global_Props)
    bpy.types.Material.is_sauna_cloud = BoolProperty()
    bpy.types.MATERIAL_PT_preview.prepend(draw_sc_material_checkbox)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)
    bpy.types.MATERIAL_PT_preview.remove(draw_sc_material_checkbox)

if __name__ == "__main__":
    register()

To answer the question, in an update or items method self is the propertygroup and self.id_data the ID object down the chain it belongs to. Scene in this case.
To get the enum value in either
self.matlist

Consider defining an enum and using same on material and object to poll instead of relying on naming convention.
enum = EnumProperty(... our types ...)

bpy.types.Material.sauna_type = enum
bpy.types.Object.sauna_type = enum

You can't set properties of ID objects in a draw method.
In the update method, to do same as above
ob.active_material = bpy.data.materials.get(sc.matname)

however IMO far better to poll a pointer. Import from bpy import context into the poll method to get context object. eg using matching enums,
def material_poll(self, material):
    from bpy import context
    ob = context.object
    return material.sauna_type == getattr(ob, "sauna_type", None)

or via name slicing method used in question


How to create a vertex on a parallel edge?

Select the edge (as you did in the screenshot), press RMB > Subdivide. Hit 1 to enter Vertex Edit Mode. Select the new vertex, double-tap G to move the vertex along the edge with Vertex Slide.


Why can't I see any transparency on my material with Eevee?

First of all with Principled BSDF you don't have to mix it with Transparent because it already has its own transparency mixer, Alpha slider. The second - in material tab in settings make sure your Blend mode is 'Alpha Blend' and 'Show Backface' is enabled.

UPD. 'Show Backface' option indeed shows the back sides of the polygons but simultaneously stops to show the front sides. I guess in some cases it can be used as a kind of fake semi-transparency, but in fact it is not.


Missing threshold in the post processing section

This panel changes depending on if your render engine is set to Cycles or Blender Render in the info bar at the top of the Blender window:

You have probably changed the render engine to Cycles in your current file, but in the new file it goes back to the default Blender Render.


How to set bpy.context.window.scene in the right context?

I think the answer to my question is a simple copy of context. So:

ctx = bpy.context.copy()

bpy.ops.render.render('INVOKE_DEFAULT')

###This is handled with some handlers, but essentially seems to work with a simple context copy

for s in bpy.data.scenes:
     if s == my_scene:
         ctx['window'].scene = s

I think this is the answer to my question, but I won't vote for it right now as I could probably cheat in future problems.
For now everything seems to work ok.


Cycles Render Material with black result [this is a bug; no problem with 2.77]

Your card is not fully supported by Blender.

From the Wiki:

  Radeon HD 7000 series (southern islands)   | Windows 7 x64 | Catalyst Beta 15.04   | Works (Not all features)

To confirm that this is the problem, disable GPU render and use CPU render, and the problem should go away. CPU will be MUCH slower, but it will support all features.

If the problem still exists with ONLY CPU rendering, then this is not the right answer.


Yes, the blender file browser is limited, but there are some workarounds for both of the things you mentioned.

Editing images. Blender has an option in the image editor to “edit externally,“ which can be set in user preferences to open images in whatever your favorite image editor program is (GIMP in my case), and then you can reload the image from the source to update it when you’re done.
Filtering. The file browser itself has search box in the header at the top that does not look in subdirectories. Try this for quick filtering of large directories.


Is it possible to change operator's bl_label on the fly?

Manipulating an operator type once registered isn't supported. *

Your options are:

override the label when drawing the interface. eg:layout.operator("some.op", text=label_override)
Modify the class, then re-register the operator(unregister() & register())

Hint, if you want to do a conditional override, Python can do this by passing a dictionary...

keyword_args = {}
if some_test:
    keyword_args["text"] = label_override
layout.operator("some.op", **keyword_args)

* (unless you modify the memory directly, which is possible but outside the scope of Blender/Python API).


You could also try a Curve modifier, if you want a fixed path, and there is no need for physics or interaction with any other objects.

Have in mind that it may lead to undesirable deformation at tight corners.


Can I control depth of focus (v depth deph of field)

You can find it under the camera property.
Select the camera and go to the camera tab.
There is a panel named "Depth Of Field". Either select an object to be your focal point or set the distance.
Set Focal length and radius (f/stops) to adjust the depth.
Here with Radius 0.06

...and here with radius 0.3

From one photographer to another, as you know the Focal length and f/stop produce the DOF effect. Same in Blender where F/stop is better expressed in radius.
You can of course use F/stop instead of radius but don't forget to change the focal length, otherwise you will have to use ridiculously small F/stops. :D


Animation doesn’t work in DAE when collada file is exported

In the export menu change the Transformation Type from Matrix to TransRotLoc.


How to learn to move objects by means of a script in python?

if you don't know anything at all as you say, i suggest you that search tutorials on YouTube (there's a lot) and you can found information about Blender game Engine in the Python API documentation Python API bge.KX_GameObject where you would see the functions that handles and object like:

move object:

from bge import logic
logic.getCurrentController().owner.localLinearVelocity.y = 0.5
## also localLinearVelocity = (0,0.5,0) or setLinearVelocity(vector, local=True)

rotate object:

from bge import logic
logic.getCurrentController().owner.applyRotation((0,0,0.02))

where owner is the object who has the Python controller (currentController) linked in it logic editor like this image:


Press Shift + Ctrl + Alt + C (perhaps the longest shortcut in Blender) and select Origin to Geometry. Or, instead, open the Toolshelf by pressing T and press the Set Origin button in the Tools tab, subsection Edit.

Depending on how you imagine the 'Center' of your object, you might instead want to choose Origin to Center of Mass. The difference is that it calculates the center point based on the volume of the mesh, rather than the average location of vertices as Origin to Geometry does.

Visually, the difference is this (blue dot is the new origin point):

UPDATE for Blender 2.8

Press the Object button at the bottom of the 3D view and see the Set Origin... sub-menu:

Here you can find both the Origin to Geometry and two similar Origin to Center of Mass options.


How can Blender be augmented to display color critical and accurate results?

Further along the research path, when comparing the output against the expected using GIMP, the LUTs generated from displaycalGUI seem to be absolutely correct and as expected. A few quick tests later however, revealed that GIMP is stuck with Relative Colorimetric rendering no matter what setting is selected. Needless to say, this answer has been validated and I'm much more comfortable standing by the process that follows. I would encourage anyone interested in Absolute versus Relative colorimetric rendering intents to read the fantastic article at Cambridge in Color.

Who is this for?

Any artist that is delivering material should be aware of the pitfalls and complexities of colour rendition. If they aren't, clients and audience members will be delivered material that isn't the artist's intention.

How long does it take?

This depends on both the hardware involved and the experience of the artist. The bulk of the time will be spent sampling on-screen values. An artist familiar with the process can expect reasonable quality results in fifteen minutes, with high quality results taking longer.

What should I know?

While it is possible to follow this guide without prior knowledge, an awareness of colour and its management is advised.

What do I need to do this?

The measurement of colours and intensity from a display or other output device requires a great degree of accuracy. This requires either a colorimeter or a spectrophotometer.

What type of device should I get?

The X-Rite ColorMunki Display and the i1Display Pro are extremely reasonably priced and high quality colorimeter instruments, differing only in their processing times in the darker regions. Both require no additional binary blobs to drive them. For greater accuracy, a spectrophotometer is advised. At this time, the ColorHug or other measuring instruments cannot be recommended.

What software do I require?

The software that comes pre-packaged with the various devices is often lacking in artist-driven control so much so as to make the software effectively useless. With specific regard to Blender and other motion picture forms of colour management, the software must support the generation of 1D and 3D LUTs. One of the most sophisticated pieces of software available to achieve this is dispcalGUI, which is built atop of the robust ArgyllCMS toolset. In some instances, you will also require the ArgyllCMS application files.

What should I know about my hardware?

If we zoom into a single pixel on your screen, we will typically see a set of three unique micro emitting regions. These regions are normally red, green, and blue. What many artists don't realize however, is that the colours of the red, green, and blue filters are unique and different across a range of hardware, despite often being labelled "sRGB", and vary immensely. The quality of the filters, spectral output, intensity output at various levels, age of hardware, white point, and a plethora of other factors all contribute to a near random range of output values for any given RGB triplet output to them. The limit of the range of colours, or gamut, a display can produce is permanently bounded by the colour of these emitting regions.

Even if a display is capable of fully covering the volume of a small gamut such as sRGB, it does not mean that an artist can use unadjusted RGB values to display sRGB content. The values must be evaluated for their intended colour against the actual output the display produces. This is known as characterizing or profiling.

I have a wide gamut display.

Expensive wide gamut displays, from Sony Trimaster ELs and Flanders Scientifics to less expensive Eizos and Lacies, increase the chance of incorrect colour output because the colour of the individual RGB emitters are radically different from the canonized default of sRGB. An artist using such a panel must exert extra care and attention to settings or risk never accurately outputting sRGB primary based colours. This answer relies on a wide gamut display being set to sRGB emulation mode for the sake of clarity.

What should I do as first steps?

If you are using a wide gamut display, ideally enable sRGB mode. This will trigger a low level hardware adjusted setting that will emulate sRGB output from your wide gamut display.
Backlight technology takes time to warm up to a constant level, so assert that your display has been illuminated for at least twenty to thirty minutes. This includes not being in a standby or power save mode.

Do I need to do anything prior to proceeding?

Colour management and display can be complicated by various operating systems and applications, and no operating system nor piece of software can insulate you from these complexities.

If you have previously calibrated and profiled your display, you must disable any previous settings at your operating system level. This is because each calibration and profiling attempt is specifically geared to a particular set of settings and device states. If you fail to do this, your effort from here forward will be worthless.

I have downloaded the software and have my measuring device plugged in. What next?

Launch displaycalGUI. You should see something close to the screenshot below.

Under the Options, make sure that Advanced Options are enabled, and that Black and White drifting compensation is turned on. These settings reduce temperature from adversely influencing your measurements.

Profiling

Select the Profiling page, and you are ready to begin characterizing your display's response to known values.

Some may be wondering why we are purposefully skipping the calibration phase. The reason for this is brevity, but also practical. When we calibrate a display, anything beyond hardware controls requires the computer's video card to store intensity curves on it. Sometimes, due to broken drivers or otherwise, the intensity curves may be dropped without an artist becoming immediately aware. The net effect of this is that the profile generated becomes useless, and worse, many hours of colour critical work can be lost.

For more experienced artists, feel free to use the interactive adjustments to steer your display into the sRGB target as best as you can. If there is interest, this can be covered in a later answer.

From the Profiling page, select the sRGB swatch set. This will use a set of test patches that will model the display's response with particular focus on important sRGB gamut values.

From the Options menu, select Measure testchart, disable the calibration within the profile, and position your instrument as directed.

Select Start measurement and wait for the process to complete.

Generate the profile

When the software completes, you will have generated the response data from the known swatches. This now needs to be converted into an ICC / ICM file. Select Create profile from measurement data and select the data directory created from the previous step to find the correct file.

Create the 3D LUT

Many high end imaging applications do not use ICC based colour management systems as it is inappropriate for photographic and scene referred imaging. As a result, we will need a particular type of file that OpenColorIO, the colour management system in place within Blender, can understand.

The relevant selections we need are as follows:

Our output space coming from a default Blender configuration assumes sRGB / REC.709 coloured primaries, sRGB D65 white point, and sRGB transfer curve. As such, we select the Source profile to be the sRGB profile included with Argyll.
We want an unmodified tone curve.
Our Target profile is what we want to filter the values from Blender coming out of into. We select the profile we generated from the output above.
To avoid inconsistent bending of our values, we select Absolute colorimetric. This will attempt to display as close to a true D65 sRGB image regardless of our current display's white point. If we wish to have the software compensate for our measured white point, we should select Relative colorimetric. These are the only two most mathematically correct rendering intents as a general rule, with many others being nonstandard and custom approaches.
We select the Sony Imageworks 3D floating point LUT format, with full range input and output.
The maximum LUT size assures best quality conversions where available.

Hooking the 3D LUT into Blender

The final step is to hook the 3D LUT we generated into the Blender display chain output transformation. This will require editing the OpenColorIO configuration file and placing the generated 3D LUT above into the correct directory.

Our first step is to copy the generated 3D LUT into the correct directory so that Blender can utilize it. The 3D spi3d file should be placed in the colormanagement/luts directory below your installation. That is, if we are using version 2.74, the full path from within our base Blender directory would be:
    /bin/2.74/datafiles/colormanagement/luts

Finally, we need to adjust the config.ocio file. Open the config.ocio file using a text editor.

<BLENDER_DIRECTORY>/bin/2.74/datafiles/colormanagement/config.ocio

We need to first create the actual colorspace reference within the file. We will use the generic sRGB float based transform as a base, and simply append our corrective 3D LUT to it. After the sRGB transform definition, add the following transformation stanza:

- !<ColorSpace>
    name: sRGB Corrected
    family: display
    equalitygroup:
    bitdepth: 32f
    description: |
      Corrected sRGB display
    isdata: false
    allocation: uniform
    allocationvars: [-0.125, 4.875]
    from_reference: !<GroupTransform>
      children:
        - !<FileTransform> {src: srgb.spi1d, interpolation: linear, direction: inverse}
        - !<FileTransform> {src: <NAME_OF_YOUR_LUT>.spi3d, interpolation: best}

At the top of the file, we will need to add our sRGB Corrected transform to our list of options for the view outputs.

  sRGB:
    - !<View> {name: Default, colorspace: sRGB}
    - !<View> {name: RRT, colorspace: rrt_srgb}
    - !<View> {name: Film, colorspace: srgb8}
    - !<View> {name: Raw, colorspace: Raw}
    - !<View> {name: Log, colorspace: lg10}
    - !<View> {name: Corrected, colorspace: sRGB Corrected}

This will enable you to view your transform in the Scene's colormanagement settings via selecting the option Corrected.


By default, the Bevel modifier adds bevels to every edge of your mesh, including all the edge loops and the ones around the hole. That's why it messes up your mesh.

To fix this, simply toggle the limit method of the Bevel modifier to "angle", and adjust the angle threshold, so that only the outer edges are affected.

Alternatively, you can change the bevel limit method to "weight"; and in edit mode, select certain edges which you want to add bevel to, and adjust their bevel weight in the item tab (press N to bring up the tab if it's hidden).

The advantage of this method is that you can precisely control where and how much the bevel modifier takes effect. A bevel weight of 1.0 means full depth, and 0.5 bevel weight means half depth, etc.

BTW, your cube mesh currently has unapplied scale transform (its Z scale value isn't 1). This will cause the bevel to appear wider along Z axis. You may want to apply its transform (select the object, Ctrl+A, and apply scale) before applying the bevel modifier.


Your fluid film is too thin so that no fluid particles are created. Make it a bit thicker and it works.


Particle system adds some pattern to a mesh

Hair particles will reveal low-poly geometry like this in most cases. The best way to fix this is to use more geometry, making the model smoother. Try adding a subdivision surface modifier, or manually adding cuts and subdivisions to the model.
You could also try using some larger, longer particles, and maybe some more of them as well. This would help make the hair look more "full".


Is there a way to make a hair particle look like a mesh I've already made?

There are a few add-ons like Hair Net that can generate and hair particles to follow a given curve, fibers (converted curves, just edges), or sheets (hair cards).
Have a look here: How can I merge this Head and Body models?
Hair cards, as used for game characters, can be used directly for the add-ons.
If you have sculpted hair you can layout Bezier-Curves on the surface of it. Just activate the snapping tool.
After you have done a complete layer of curves, duplicate the curves 2 or 3 times, scale and move them a little. Don't forget to Apply Scale and Location (Ctrl+A in Object Mode) for the curves and the head (emitter) when you're done with the layout. That's important.
Finally, generate the Hair Particle System. Select the Curve objects first, then the head/scalp object (emitter). The emitter selection must be orange, the curve selection must be red.

Sculpted hair (purple), curves (black), duplicated curves, finally the generated hair particles (green)
In the Hair Net add-on in the N-panel, select a Hair Setting (optional) and press the "Curves" button. The script may run a while.
Switch Children type to Simple and give it a tiny bit of Roughness and Randomness in the Hair Particle settings. Use a small value (like 0.02 m) for Radius of the children.
Hair grooming takes a bit of practice. Try to do the hair layered, and don't let the hair guides intersect. That can look messy if you activate the hair children. Make sure you have your model on a real-world scale and adjust values of the Hair Shape. (Shape: -0.850, Diameter root: 0.03 m, Tip: 0.02 m (or 0.00 m). With the default values, the hair looks like ropes in Cycles.
(Fibremesh, the 2nd button of Hair Net addon, are curves that are converted to mesh.)
Note:
The HairNet add-on 0.6.3 for Blender 2.9x has an issue at the moment. The generated hair sometimes moves down the Z-axis a little if you add more than one Particle System. You can fix this when you turn off the Particle System in the viewport (turn off the Monitor icon in the Particle System Settings). Or in Comb Mode, select all hair guides (Ctrl+A), and move them up again (G, Z, and use mouse).


how to create a shiny latex like material in blender cycles

I would just use the principled shader with zero roughness. The node set up you have should work just fine too. Not sure what you dont like about it.


Uninitialized Image TreeDoubleBranchTexture from object "Tree"

I was having this problem too. It seems I had not actually created an image, just a slot for one. I managed to fumble around until I found Fill Image With UV Grid. Then I had an actual image, which I saved, and then it worked.


UV Pack Islands operator has an option allow/forbid island rotation. Just press F6 after packing to adjust operator preferences like in 3D View operators.


Can I use an instance of an object created with a custom operator to run other custom methods in the same class?

I am trying to write a Python code to save a 3-d model created in Blender so that a simulation program can read it.  In order to save the data from the different types of objects, I have a list of if statements.  I was thinking I can avoid that if I could take advantage of the fact that Python is an object-oriented language and each object could have its own method to save data.
After reading the following question and answer,
Is it possible to create an own object data type through Python?
I think that the answer to my question is no, that will not work.  I may try to use a custom property to store the information I need for each object when I create it.  Then I could just get the value of the custom property instead of having a bunch of if statements.
I think custom properties have an update function, so that if the object is modified, I could catch that in my Python code and adjust the custom property.  Since I am only creating 3d models and not using other aspects of Blender, hopefully a custom property would not cause problems with memory use and execution time in Blender.


Is it possible to create a modal operator with a modal keymap in Python?

I don't know how to use modal keymaps, but it is quite easy to write such an event system on your own.

Here is how I would do it now (I just wrote this the first time, so maybe I forgot something):

at first we need 2 classes to store the keymap information:

class EventCollection:
    def __init__(self):
        self.events = {}

    def new_event(self, name, event_settings):
        self.events[name] = event_settings

    # assumes that only one event can happen at the same time
    def get_matching_event_name(self, event):
        names = self.get_matching_event_names(event)
        if len(names) > 0:
            return names[0]
        return None

    def get_matching_event_names(self, event):
        return [name for name, description in self.events.items() if description.fits_event(event)]

class EventSettings:
    def __init__(self, event_type, event_value, shift = False, ctrl = False, alt = False):
        self.type = event_type
        self.value = event_value
        self.shift = shift
        self.ctrl = ctrl
        self.alt = alt

    def fits_event(self, event):
        return event.type == self.type and \
                event.value == self.value and \
                event.shift == self.shift and \
                event.ctrl == self.ctrl and \
                event.alt == self.alt

Here is how you can use these two classes in a modal operator

class TestKeymap(bpy.types.Operator):
    bl_idname = "my.modal_operator"
    bl_label = "label"
    bl_description = ""
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return True

    def modal(self, context, event):

        name = self.events.get_matching_event_name(event)
        if name == "my event":
            print("hey")
        if name == "select":
            print("select")

        if event.type == "ESC":
            return {"CANCELLED"}

        return {"RUNNING_MODAL"}

    def invoke(self, context, event):
        context.window_manager.modal_handler_add(self)

        e1 = EventSettings("A", "PRESS", ctrl = True)

        select_type = context.user_preferences.inputs.select_mouse
        if select_type == "RIGHT": event_type = "RIGHTMOUSE"
        else: event_type = "LEFTMOUSE"
        e2 = EventSettings(event_type, "PRESS")

        self.events = EventCollection()
        self.events.new_event("my event", e1)
        self.events.new_event("select", e2)

        return {"RUNNING_MODAL"}

I think this is mostly self-explanatory, so I won't go over it in detail.
Basicly you create an EventCollection when you invoke the operator. This makes sure that it is always up to date to latest changes in userprefs.

In this example I create two events (like KeyMapItems in normal keymaps). The one is very simple and the second one shows how to mimic the selection method. It checks wether you normally select with left or right and creates a corresponding EventSettings instance.
You may rename these classes

In the modal-function you can always check if the current event matches one of the predefined ones.

This makes the system very flexible and easy to extend/change.

Is that a bit like what you wanted?


How to enable external rendering engine?

Yes, all external renderers are separate applications to Blender. The addons are simply helper scripts to pass data back and forth between Blender and the app. You definitely need to have the renderer application installed on your computer to get it to work.


Unable to make holes using boolean modifier

The problem with your file is that you have a lot of disjoint geometry and non volume geometry.

Observing a small section of the model shows a problem: A, B, and C are disjoint. (Not attached to eachother) and they therefor don't form a watertight (Manifold) volume. Also B and C even have Polygon normals  that go in opposite directions. Which you can tell by the color differences in the mesh. Purple vs Grey.

I'm sure if you study the model further, or come back to it when you have more experience with the Boolean Modifier you will see immediately all kinds of things that make it impossible to do what you are trying. I suggest a different approach, it's easier I think.

Here's a demonstration of what my approach would be to this. Use the Screw Modifier and a profile as the rotation shape. A benefit of this is you can easily change the number of vertices on the circumference of the object, by changing the 'Steps' value.

I've also used the Array Modifier to make a radial array, this arrays an object (The extruded Circle) around a fixed point (an Empty). The Empty's rotation influences the rotation of the repeated object.

Then finally you can add the boolean modifier and hide the Circle object.


It turns out that this isn't a bug. I found that I have to check "Proxy/timecode" in the movie clip editor and set "Use timecode index" to "Record run." Now it works fine.


Shading Point

is the nearest point of intersection of the camera ray with a visible object, which the render engine is currently calculating the color for (these calculations are referred to as shading)

The real View Vector

it is a vector (or a ray) in the camera space, starting from the center of the camera (or the view) and reaching the shading point

View Vector

it is a normalized view vector (magnitude = 1 or unit vector) in the camera space, starting from the center of the camera (or the view) and pointing at the shading point (it doesn't necessarily reach it )

View Z Depth

it is the Z component of the view vector (the non normalized)
it is the shortest distance from the shading point to the camera's XY plane (the is not normalized Z-depth, it is not from 0 to 1)

View Distance

it is the magnitude of the non normalized view vector, or simply the distance from the shading point to the camera's center

where to use each one: well you know enough now to decide where to use them!


Modify a single plane mesh to match image based on alphas, create shape keys

If the animation will be planar (2D) I suggest you to subdivide the continents in a 2D software (Gimp, Krita, Photoshop), make a transparent PNG for each and import every continent as "Image as planes" (it's an addon), without caring the shape of the mesh; then you can set one location "jointed" and - some frames away - the location "drifted".

If it will be 3D, all PNG planes should be subdivided, shrinkwrapped to a sphere and moved with a rotation with pivot point centered in the center of the sphere.


How to determine right vertex count for mesh?

List of objects in scene with counts (verts, faces, tris)?

I think a suitable solution can be found here. They use a len method which I'm sure might be useful in your case.


How to party add geoetry while keeping good topology (Cat nose)

Actually your topology is not really "low-poly", it's rather "medium-poly"  ;)   Here is a try, I think it works pretty well:

Previous version:


After selecting the objects you want, go to File -> Export. In the bottom left corner, you'll see a panel labeled "Export [name of file type]". There, you can click a checkbox labeled either "Selected Objects" or "Selected Only". The .ply, .stl, and .bvh files don't have these options. For example, here's the "Selected Objects" checkbox when you export to .fbx.


Bug? Material Preview mode shows only black objects (Eevee and Cycles)

So, I recently switched over to a new computer with a much-improved card: I'm guessing there was something wrong with my old card.


Yes.

Try using a mix node with the blend mode set to Color:


Why should I use an empty instead of just animating a model?

I think it is usually done to allow you to later swap the parented model with another one (maybe you start with a low-res then later switch to a hi-res), so that you don't loose the animation keyframes, because they're assigned to the empty, not to the model.

Otherwise, deleting the "old" model, you'll loose all its animation keyframes, and you would need to reconstruct the "new" object animation from scratch.

Maybe there are more or better reasons, but this could be one.


Where is the command box in the bottom left of the 3D viewport?

This box is called the Operator Panel. It only appears after you perform certain actions, and often "disappears" as soon as you click away from it or you use any kind of transformation (move, scale, rotate, or when you click on another object).
For example, if you add a cylinder (Shift+A > Mesh > Cylinder), before you do anything else, look in the bottom left corner - there will be a little text box that only says "Add Cylinder". Click this box and it will expand for more options. Once you've expanded it once, it should appear expanded for all actions until you shrink it again (eg: other things you do, like add a loop cut will cause this box to appear "fully opened"). But, it will still disappear when you click away.

Keep your eye out for this box as you perform different actions (both in object and edit mode) - you'll be surprised how much it appears. There are lots of options that you can make use of through this panel.
Alternatively, you can use a floating window with the same options by pressing F9


Blender as a VSE - can I separate my editing into multiple scenes and render as single video?

In the end, I solved this by creating a final Scene (which I called 'All_Scenes') and then adding the other Scenes as Scene strips in the VSE (Header menu: Add >> Scene).  In the scene properties, I had to configure the rendering to output as mp4.

In the Scene properties, I had to ensure the 'Use Sequence' property was ticked.

I could then render the scene with:

 blender -b demo2016.blend -S All_Scenes -a


Why is the subdivision surface modifier showing a point on my model?

Since you said you activated the "Face Orientation", i believe my suggestion was most likely not explanatory enough, sorry.

Here what i found:

So regarding the "Face Orientation", switched on here:

Blue is the outside side of a face, while red is the inside side of the face. That said, when we look at objects with the "Face Orientation" option on, normally all faces should be blue, except those parts where there is a hole and you can look into the object, where it should be all red.

Now your problem most likely came to be when you worked on the model and pressed some key-combinations while trying to use others. Blender has many key-mappings that are similar and it can therefor accidentally happen, while not in this mode you would not see a change instantly either.

So now to the solution:

Select the object, then go in edit mode pressing Tab
Press A to select all elements, it does not matter which mode you are in, be it vertices, edges or faces
Either press Alt+N to open the "Normals" menu and select "Recalculate Outside" or use the direct shortcut Shift+N

The result should look like this now:

Now we can deactivate the "Face Orientation" mode to see this:

You may need to iron out those vertices if you moved them to find the problem.

Should you have some faces that just don't want to turn the right way with this method, you can always select the corresponding face(s) and then press Alt+N to select "Flip".

From here on out i wish you a good time Blending.


Reverting an object back to mirrored state (for symmetrical editing) after "APPLY" in Modifier panel was used

Delete half of your mesh, add a mirror modifier. Now you can tweak your mesh and all changes will be replicated across the selected axis.


Blender python script - unhide collections from render

Ok this was my bad. I got it right first time by using:
bpy.data.collections["COMMON REAL ESTATE"].hide_render=False

BUT, I have nested collections in collections. So in this example I wanted to render objects in "COMMON REAL ESTATE", but "COMMON REAL ESTATE" is a child to another collection called "REAL ESTATE", which you also have to activate for rendering. It's not like the "Exclude from View Layer" checkbox where you can just dive in and tick the box anywhere in the chain and it'll render.


Straighten non planar vertices into a circle

Yes, for straightening that circle you can do like @Duarte Farrajota Ramos said (selecting that circle and pressing S+Z+0)

But that topology will sooner or later cause issues, so I did a quick gif to show you an example of fixing that topology, it stretched a few lines but nothing too noticeable on the mesh.

What I did:

I straightened that circle with
S+Z+0)
Since this object can be perfectly mirrored on all sides I deleted
the left and back part to modify it faster.
Then I started to merge some vertices using W>Merge>At Last
I duplicated that part and inverted with S(lock on an Axis)>-1
And then I joined all parts using the Snapping Tool to Merge at the Closest Vertex.
Finaly I Removed Doubles with W>Remove Doubles


Eevee bump and displacement modifiers are low resolution?

It is caused by the library that EEVEE use:

Documentation

  Material

  Bump Mapping

  As of now, bump mapping is supported using OpenGL derivatives which are the same for each block of 2x2 pixels. This means the bump output value will appear pixelated. It is recommended to use normal mapping instead.

    Tips: If you absolutely need to render using Bump nodes, render at twice the target resolution and downscale the final output.

I try some approach to resolve this problem since about 10 month ago. But there isn't a plausible solution that can be easily done without changing bump map. And 2x resolution suit my application.


Here is the code corrected,...
I have used a function from here for override context: link
and an operator described here for updating the view3D camera change: link

import bpy

def AssembleOverrideContextForView3dOps():
#=== Iterates through the blender GUI's windows, screens, areas, regions to find the View3D space and its associated window.  Populate an 'oContextOverride context' that can be used with bpy.ops that require to be used from within a View3D (like most addon code that runs of View3D panels)
# Tip: If your operator fails the log will show an "PyContext: 'xyz' not found".  To fix stuff 'xyz' into the override context and try again!
for oWindow in bpy.context.window_manager.windows:          ###IMPROVE: Find way to avoid doing four levels of traversals at every request!!
    oScreen = oWindow.screen
    for oArea in oScreen.areas:
        if oArea.type == 'VIEW_3D':                         ###LEARN: Frequently, bpy.ops operators are called from View3d's toolbox or property panel.  By finding that window/screen/area we can fool operators in thinking they were called from the View3D!
            for oRegion in oArea.regions:
                if oRegion.type == 'WINDOW':                ###LEARN: View3D has several 'windows' like 'HEADER' and 'WINDOW'.  Most bpy.ops require 'WINDOW'
                    #=== Now that we've (finally!) found the damn View3D stuff all that into a dictionary bpy.ops operators can accept to specify their context.  I stuffed extra info in there like selected objects, active objects, etc as most operators require them.  (If anything is missing operator will fail and log a 'PyContext: error on the log with what is missing in context override) ===
                    oContextOverride = {'window': oWindow, 'screen': oScreen, 'area': oArea, 'region': oRegion, 'scene': bpy.context.scene, 'edit_object': bpy.context.edit_object, 'active_object': bpy.context.active_object, 'selected_objects': bpy.context.selected_objects}   # Stuff the override context with very common requests by operators.  MORE COULD BE NEEDED!
                    #print("-AssembleOverrideContextForView3dOps() created override context: ", oContextOverride)
                    return oContextOverride
raise Exception("ERROR: AssembleOverrideContextForView3dOps() could not find a VIEW_3D with WINDOW region to create override context to enable View3D operators.  Operator cannot function.")

bpy.ops.object.select_all(action='DESELECT')
bpy.ops.curve.primitive_bezier_circle_add(radius=.25, enter_editmode=False, location=(0, 0, 0))
bpy.ops.transform.rotate(value=1.5708, orient_axis='X', orient_type='GLOBAL', orient_matrix=((1, 0, 0), (0, 1, 0), (0, 0, 1)), orient_matrix_type='GLOBAL', constraint_axis=(True, False, False), mirror=True, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1)
bpy.ops.transform.translate(value=(0, -2, 0), orient_type='GLOBAL', orient_matrix=((1, 0, 0), (0, 1, 0), (0, 0, 1)), orient_matrix_type='GLOBAL', constraint_axis=(False, True, False), mirror=True, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1)
bpy.ops.object.convert(target='MESH')
bpy.ops.object.select_all(action='DESELECT')
bpy.context.view_layer.objects.active = bpy.data.objects['Cube']
bpy.data.objects['Cube'].select_set(True)
bpy.data.objects['BezierCircle'].select_set(True)
bpy.ops.object.mode_set(mode='EDIT', toggle=False)
oContextOverride = AssembleOverrideContextForView3dOps()
bpy.ops.view3d.view_axis(oContextOverride, type='FRONT')
bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
bpy.ops.mesh.knife_project(oContextOverride)


FCurve handles to 3D Bézier spline control points

The points used by an fcurve are a 2D version of the bezier curves you use in the 3D viewport. To convert an fcurve into a 3D bezier curve we just need to add a Z axis value to the locations.

import bpy

anim_fcurves = bpy.context.object.animation_data.action.fcurves

# index 1 is the Y location fcurve
src_fcurve = anim_fcurves.find('location', index=1)

vis_curve = bpy.data.curves.new('YLocCurve', 'CURVE')
vis_spline = vis_curve.splines.new('BEZIER')
vis_spline.bezier_points.add(count=len(src_fcurve.keyframe_points)-1)

for i,fcp in enumerate(src_fcurve.keyframe_points):
    p = vis_spline.bezier_points[i]
    p.co = (fcp.co[0], fcp.co[1], 0.0)
    p.handle_left = (fcp.handle_left[0], fcp.handle_left[1], 0.0)
    p.handle_left_type = 'FREE'
    p.handle_right = (fcp.handle_right[0], fcp.handle_right[1], 0.0)
    p.handle_right_type = 'FREE'

data = bpy.data.objects.new('YLocCurve', vis_curve)
bpy.context.scene.objects.link(data)

That will turn an fcurve into a bezier curve object in the 3D viewport. How you export that to another application depends on the file format you are using, but in general you want the three locations for each point so that the other program uses the three points to define each point and it handles.

While mostly you can copy the handle type, the fcurve can have an AUTO_CLAMPED handle type that is not valid in a 3D bezier curve.


I figured it out.

Set Transformation orientation to local to align the origin with the object. This didn't solve what I really wanted to do which was to rotate the empty on the local x-axis. It ended up rotating crooked.

What I had to do was press r x then x again to rotate on local x-axis.


Get smooth and slow 25fps video from 50fps footage

After some research, and the help of the people who commented and answered my question, I now understand that Blender handles output frame rates differently to the way it is done in commercial video editing programs (ie. Power Direcotr, Adobe Premiere Elements).

When the output frame rate does not match (ie. is smaller or higher) the footage's input rate, the result is either a slowed down or a sped up video.

It might seem obvious to Blender aficionados but wasn't to me as a newcomer, who was used to video editing programs that preserved the original speed of the video, whatever the chosen output frame rate.

So there are two ways to slow down a video: simply lower the output frame rate or skip frames with the frame step (thanks @Edgel3D). Both work but I recommend using the frame rate as it results in an exact frame rate (using frame step resulted in a video with 25.0499 fps). However both also affect the entire video, and individual sequences thus need to be adjusted singly using a speed effect.

In my case, I was already unknowingly slowing down the video as my output frame rate was halved (I had muted audio), and additionally slowing it down with the 0.5x speed effect, resulting in a jerky output video.


how to create a flat glowing eyes in blender

You can just add a "Emission" Node and turn the color to pink and then apply the material to the eyes.

Then apply the material to the eyes.

Add another material to the rest of the mesh and behold! Your wizzard/witch looks cool!


You want to pack the image into the blend "file" right after you set the pixels.
I'm not sure if otherwise it's expectable that the data is lost over time (it definitely is if you close and reopen Blender), but I guess it's just kept in volatile memory if you don't pack it.

You can do so by simply calling

my_image.pack(as_png=True)

Note this doesn't mean the blend "file" itself has to be saved, it can in turn be an unsaved instance in memory.

The optional as_png=True is required as Blender otherwise tries to pack a file from disk and store its raw data in the blend, but not having a backing file and thus not knowing the file format, you have to tell it to simply pack it as if it would be an uncompressed PNG file (at least that's how I understood it).

This also makes it possible to mass-dump the generated images via File > External Data > Unpack All Into Files.

To detect if an image has been packed or is in volatile memory, open the UV/Image Editor, select the image in question, and check the text of the "Image" menu to the left of the image selector. If it is postfixed with a star (like Image*), you didn't pack it yet.


Some faces appear darker BUT normals are okay

when this happens to me i just select it and apply "faces>shade flat". if someone has a better answer please share.


How can I make a closed flat base for an object?

In Edit Mode, select all the bottom vertices and then press SZ followed by 0 then Enter.

This scales them all to zero on the Z access which will flatten the bottom edge.

Now press F to fill a face for the base.


Objects and floor being cut off when zoomed in

You are editing your scene camera's clip settings, when you really need to be editing your view's clip settings.

Press N to bring up the side menus, go the the "View" tab, and you should find the relevant options.


In viewport, mesh is see-through, objects behind it are displayed on top

Make sure that the display properties of the object that is appearing on top of other objects is not X-Ray


Why is the displacement texture weaker on certain parts of the object?

You need to add a Displacement Node (Vector > Displacement) between the Noise Texture and the displacement connection of the Material Output:


remove weight by part of the mesh in weightpaint mode

You can hide the part you want in edit mode: select and use H.

Then go in vertex paint mode and click on the 'vertex selection' button. The unwanted part will be hidden.

Then select all the remaining vertices using A to paint on them.


import bpy

node_names = ['Texture Coordinate', 'Mapping', 'Image Texture','Image Texture 2','Diffuse BSDF','Material Output']
nodes = bpy.data.materials['Material'].node_tree.nodes
startlocy = 0
startlocx = 0

locx = startlocx
locy = startlocy
# Set the first node's X and y coords to 0,0
nodes[node_names[0]].location.x = locx
nodes[node_names[0]].location.y = locy
# For index, node in the list 'node_names'
for i, node in enumerate(node_names[1:]):
    # Set the last used node
    lastnode = node_names[i]
    #if the last node AND the current node are texture images
    if nodes[lastnode].type == "TEX_IMAGE" and nodes[node].type == "TEX_IMAGE":
        # Set current node to the height of the last one plus 200px
        locy += nodes[lastnode].height + 200
    else:
        # Otherwise, set the y to the default (0)
        locy = startlocy
        # Set the x to the width of the node plus 50px
        locx += nodes[lastnode].width + 50
    nodes[node].location.x = locx
    nodes[node].location.y = locy

This seems to work if your texture nodes have the same width, else only the highest node influences the next x position. You need to write the node names in the right order in the list node_names.


How can I pass arguments to an Operator inside a Macro Operator?

Macro.define("TRANSFORM_OT_translate") returns a OperatorMacro which has a properties attribute.

Eg:

op_macro = Macro.define("TRANSFORM_OT_translate")
op_macro.properties.value = (1, 2, 3)


Bake Fluid Simulation via CLI or Python?

It's a bit more complicated than it could be because fluid simulating baking is only exposed as an operator. That means it expects an active object in the context, which is usually provided by the user interface that is not available in background mode.

It is possible to pass this object to the operator manually however. The following is an example script that bakes all fluid domain objects in all scenes:

import bpy

for scene in bpy.data.scenes:
    for object in scene.objects:
        for modifier in object.modifiers:
            if modifier.type == 'FLUID_SIMULATION':
                if modifier.settings.type == 'DOMAIN':
                    bpy.ops.fluid.bake({'scene': scene, 'active_object': object})
                    break

This works when executed from the command line with a command like this:

blender --background file.blend --python script.py


Why does perspective always have xray on?

This occurs due to your Start Clipping being to small, to fix that open up your NPanel, then go to the View section and change the Start clipping value to 0.100

Or either it could be the Limit Selection to visible button next to the Vertex/Edge/Face Select properties, as mentioned by Mike Metcalf


Missing AO output socket in Render Layers node

Oh, nevermind. All I had to do was turn on AO in the Render Layers Tab->Passes->AO


You want to have a look at the ops.wm.context_... family of operators, which are 'generic' operators that can be used to define a value (or cycle through a set of values) of any compatible property accessible through context. This avoid the need to define a custom operator.

E.g. for an enum property like context.scene.render.engine:

import bpy

# Creates a menu for global 3D View
class customMenu(bpy.types.Menu):
    bl_label = "Sub"
    bl_idname = "view3D.sub"

    # Set the menu operators and draw functions
    def draw(self, context):
        layout = self.layout

        layout.operator("rigidbody.objects_add", text="A Add Active").type = 'ACTIVE'
        layout.operator("rigidbody.objects_add", text="B Add Passive").type = 'PASSIVE'
        op = layout.operator("wm.context_set_enum", text="Set Cycles Renderer")
        op.data_path = "scene.render.engine"
        op.value = 'CYCLES'

def register():
    bpy.utils.register_class(customMenu)
    bpy.ops.wm.call_menu(name=customMenu.bl_idname)

def unregister():
    bpy.utils.unregister_class(customMenu)

if __name__ == "__main__":
    register()

Note that you can also use layout.prop() and the like, just like in a regular panel - but beware, most of our widgets are not really designed nor tested in menus… Afaik in 'official' UI we only do that for some boolean properties (giving small toggle boxes in the menus). Seems to work rather well with enums, though, producing a sub-menu:

import bpy

# Creates a menu for global 3D View
class customMenu(bpy.types.Menu):
    bl_label = "Sub"
    bl_idname = "view3D.sub"

    # Set the menu operators and draw functions
    def draw(self, context):
        layout = self.layout

        layout.operator("rigidbody.objects_add", text="A Add Active").type = 'ACTIVE'
        layout.operator("rigidbody.objects_add", text="B Add Passive").type = 'PASSIVE'
        layout.prop(context.scene.render, "engine")

def register():
    bpy.utils.register_class(customMenu)
    bpy.ops.wm.call_menu(name=customMenu.bl_idname)

def unregister():
    bpy.utils.unregister_class(customMenu)

if __name__ == "__main__":
    register()


Ok, so I assume that one leaf was made, used as a particle system which was applied as an object and then this leaves object was already joined to ground object to create one object but the vertices of the leaves have the leaf texture and the ground vertices have the ground texture. Is that correct?

It looks like you already have each thing unwrapped into one UV map so if I've understood you correctly baking two assigned materials into one diffuse material is what you want to do, correct?

Baking two material textures into one:

1) Open the node editor and the UV image editor. In the UV image editor create a new image and give it the dimensions you want your new diffuse image texture to be. Make sure the dimensions are quite big because it gives you the option to scale it down if you want to crop it. Now save it to a location you can remember.

2) Go to node editor, click on your object and go into material of either object and add an image texture. DO NOT CONNECT IT TO ANYTHING. Now open your new blank image inside the image texture you added (the image which you created and saved earlier).

3) In the render tab, scroll down until you see "Bake". Expand the tab and choose Diffuse (it should be the default option). With the image texture selected in the node editor (make sure it's highlighted) click "Bake". This should create a new material which includes the leaf materials for each leaf plane in your object.

4) Now you should be able to delete the leaf planes and use the new texture on your ground plane. If you want to, use GIMP or photoshop to crop the newly baked image so that there are no transparent parts. Now you can UV unwrap the ground plane again so it fills the UV map and align it to the newly cropped baked image texture so it all lines up if it doesn't already.

You can also create a normal map using the same method by duplicating the ground plane, deleting the leaf geometry in edit mode and UV unwrap it. In the bake tab, choose "Normal", select your complete mesh and shift select your new edited ground plane mesh second and in the bake tab click the option "Selected to Active". Then click "Bake".

Remember to duplicate everything and move it to a different layer or save a back up file before you do anything so that you don't lose everything if you make a mistake.

If I've missed a step, please feel free to edit my answer because I'm away from my PC and can't double check :)

Hope this is what you were looking for :)


Not sure about your problem... The shortcut for the eyedropper is S. To set the shortcut: Preferences > 3D View > Image Paint > Image Paint (Global) > Sample Color.


grease pencil rig+ stroke getting messed up

From a quick glance it looks like you've assigned the same vertex to multiple bones so you're getting multiple movements.Try assigning the hand just to the hand bone and remove from the arm etc.
From my experience with Grease Pencil weight painting seems to only apply a 1 or 0 in 2D as opposed to actual weights unfortunately (I'm currently in an experimental build so may just be the version I'm in).
Hope that helps
Matt


tranform the origin/pivot point of multiple objects

Just to illustrate how to change origin for multiple objects at once as @Delagone suggested.

Position the 3D cursor
Select all the objects
Go Object > Set Origin > Origin to 3D Cursor


You can achieve this using freestyle:

In your render properties tab, at the very bottom, activate freestyle.
Then go to the render layers tab and scroll down to the freestyle settings.
For every line style you want to display, you have to create a separate line set. For every set you can set a number of options.
To color the outer border of the paper black, check "Silhouette" and "Border" and create a line style with black color underneath
For showing creases, adjust the angle settings of a line set.

More information can be found here:

Introduction to freestyle:
https://www.blender.org/manual/render/freestyle/introduction.html

Line set settings:
https://www.blender.org/manual/render/freestyle/parameter_editor/line_set.html

Modifiers - you can even color by crease angle:
https://www.blender.org/manual/render/freestyle/parameter_editor/line_style/index.html

Also take a look at this page - there are a number of dense, but very informational articles and infographics about freestyle:
http://blendernpr.org

If you save the line styles and sets in a blender file, you won't even have to script all this, just enable it and run your script.


Uninstalled my old python version. Blender is running now.


Blender expects addons to be a zipped directory of python scripts.
if somehow installing an addon gives the error failed to get addon path , investigate the addon and make sure it has the following structure.

addon.zip
   |
   |--directory_name/
          |
          |--__init__.py
          |--script.py
          |--script2.py
          |--etc...


How to make a high-poly monopoly car piece

Actually the solution depends on your current topology, so you could share your file if you want us to give a try.
If I had to do the back of the car from scratch I would begin with a 8th of a subdivided cube that I would stretch and mirror:

Then I would cut the shape of the outgrowth with the knife tool:

Extrude it:

Move the vertices:

Then retopologize:

For the rear, you can create a new edge loop then again, extrude:

So from your current topology:

I would simplify like that, then follow the same techniques:

According to this article, the original car could have been inspired by an old Kurtis Kraft Midget Racer, while others surmise it could be a 1934 Mercedes Grand Prix W25, a Maserati 8CTF, or an Alfa Romero 158.
In my opinion it's a mix but the Mercedes is pretty close:

The Alpha Romeo:


Having trouble rendering fire+smoke with transparency

Use denoise node in compositing instead of the one you are using. It is better for viewports only.
To use denoise node,go into the compositing tab and SHIFT+A to add denoise node. Now add color,normal and albedo in their respective channel.
To get better results,enable denoising data from the layer settings.
Disable the denoiser you are using and it will give better results


Question about using multiple graphic cards to rendering

Nvidia has disabled SLI for the 1060.

Blender can make use of multiple gpus that are plugged in but not connected to each other (via corrsfire or SLI or whatever there is).

But there are a few downsides:
 - the memory of the cards don't add up. as both cards need to store the
   scene information in the memory, the card with less memory is the
   bottleneck
 - you'll have a "dead" card in your setup almost all the time (except when you are actually rendering)


BGE: Can Python do more than the Logic Bricks?

Yes a python script can do more than logic bricks. Most likely you will use both.

There are three types of logic bricks - sensors, controllers and actuators. Sensors are used to input data to the game engine such as keyboard and joystick or internal data like collisions that you may want to react to. Actuators perform actions, they may start an animation or they may alter a property. Controllers then provide a connection between the sensors and actuators.

Controllers are where python comes in, a python controller allows you more control between the input and the action. In the simplest form you may use a python controller that does a test before starting an actuator or maybe dynamically adjusts a sensors properties and at the other end of the scale you can go all the way and just use one python controller which is connected to an always sensor that looks at all of the input and alters all game data itself.

So start by using logic bricks to get your game running and then when you get stuck with something that just doesn't work the way you want it to, create a python controller for it.


Your mesh is a bit messy, you have floating edge along its axis, you can see if you hide some faces:

What you could do to fix it quickly is enabling the Affect Only Origins option:

Move the origin very slightly to the right:

Disable the option, then back in Edit mode, select all, go in the Mesh menu > Symmetrize:

In the Operator box choose the right axis (in your case +Y to -y)

Your mesh has been symmetrized and the floating edges has been deleted in the process.


Your scale is very large.

This means that lights need a lot more power in order to light the objects.

For example a 100W light bulb will light a stadium, you need lots of light.

So to fix this, either scale your model to life size, or increase the values to something scary.

Also looking at your backdround color you can increase the environmental lighting by making your background white (I suggest using the RGB input node rather than the brightness contrast node).  You can always increse the luminance of the background color to modify the envronmental lighting level.

This is a simple render with only 2 lamps, a very slight background.  There's an issue with your whiskey glasses, the mesh needs some work, but you get the idea.  Start with no lights, setup your background, then highlight with some lighting for mood.

And this is the same lighting with a white background (same strength = 100 )


For your workflow to work, you need the exact match for the camera, both in placement, rotation and perspective. Not a trivial thing to do, and hard and time consuming to do manually.

You can try (Fspy)(https://fspy.io/)
Fspy is an app to match the perspective of a camera in 3d space to a photograph.

Open the Fspy app. and import the image. Set the lines so that you match parallel lines and set the origin where you want it and save the fspy project.

Install the fspy importer addon and then import the fspy project into blender 2.8

Once you open the fspy project, blender will create an active camera that matches the lens and placement of the original camera, and uses an the image as background for reference.

It is then quite easy to create a box that matches your original object.

Then you can unwrap the UV using Project from View.

Create a material that uses the UV map as coordinates for the texture, and the image as color for the shader.

Done. Over and Out.


Installing a Python module in Blender's Python API

Python loads any module from the directories in sys.path. Try this in the interactive Python console in Blender:

import sys
print('\n'.join(sorted(sys.path)))

That'll give you a choice of paths. Alternatively, you can place your scripts next to your blend file, and in the blend file text editor itself have a script like this:

import bpy
import sys

p = bpy.path.abspath('//scripts')
if p not in sys.path:
    sys.path.append(p)

Make sure the script name ends in .py and the 'Register' checkbox is checked. After this runs you can import Python modules from the scripts subdirectory of whichever directory holds your blend file.

Also make sure that the directory names are actually valid Python names, so without spaces.


Armature not bending with connected bones

Unfortunately, the bones were upside down, so they were not moving correctly. When bones are upside down, the only thing that will rotate correctly are the ones on the top because if done correctly, the ones on top move all the bones that are connected to it.


Why is my object appearing as a series of incomplete lines in the 3D view?

Change viewport shading from Wireframe to Rendered, Material, Texture or Solid.

To display all the edges in Wireframe Shading enable Draw All Edges in Object Data tab.


What Transformations are calculated exactly for the sRGB Display Device in Blender's Color Management?

View transforms determine data convertion from scene referred linear information in blender to display referred formats.
Paraphrasing from the original https://sobotka.github.io/filmic-blender/

Standard.
It will only use a range of scene referred values from 1 to 1.0 (any larger values will be clipped) when converting to display referred values, and applies a transfer function ("gamma") of 2.2.
Should be avoided at all costs for CGI work. Useful in some edge cases for albedo textures, for example.
This view transform should be used when dealing with display referred images in video editing, or for grease pencil projects
Non-Colour Data.
This is a view useful for evaluating a data format. Do not expect to see perceptual values however, as it is literally data dumped directly to the screen. Use this transform on your buffer, via the UV Image Viewer Properties panel, if your buffer represents data and not colour information. This will keep it out of the OpenColorIO transformation pipeline chain and leave it as data.
Raw This is a colour managed linearized version of your data. For all intents an purposes, will look identical to Non-Colour Data, but applied to colour based data such as an image.
Filmic Log Encoding Base. This is the workhorse View for all of your rendering work. Setting it in the View will result in a log encoded appearance, which will look exceptionally low contrast. Use this if you want to adjust the image for grading using another tool such as Resolve, with no additional modifications. Save to a high bit depth display referred format such as 16 bit TIFF. This basic view is designed to be coupled with one of the contrast looks.

For a deeper explanation read:
Render with a wider dynamic range in cycles to produce photorealistic looking images
And if you really want to fall down the rabbit hole of understanding color for digital imaging read Troy Sobotka's
The Hitchheiker's Guide to Digital Color


Where to Learn Cycles Material Nodes from basics

Each node is very basic and very descriptive. For example, A Mix node mixes 2 input based on a factor value, a SplitXYZ node splits the input into XYZ. A simple online search should help if you still need clarification.

I think what you need to learn is the high level concept of shading and texturing. Look up "PBR material" basics, That should get you started learning about how the shaders behave, how inputs such as albedo, normal, roughness affects the surface, and how to create steel, plastic, etc.

I also suggest you focus on learning about the principled shader(as oppose to individual shaders such as glossy or diffuse), as it's the most artist friendly, complete, and industry-accepted pbr shading model.


If you use the Shader to RGB node combined with Greater Than node. You can differentiate between light and shadow to create a cell-shading effect.

Simply add a texture to the original Diffuse BSDF, to texture the transition between light and shadow.

This is how the effect looks in motion.

You can sharpen or smoothen the shadows edge by decreasing the lamps energy, increasing its radius and lowering the threshold of the greather than node.


Make a Pie-Specials Menu, dependent on selection type

In blenders text editor you can find a template for creating a pie menu. You will probably want to turn your script into an addon to make your menu available every time you start blender.

Starting with the pie template, you want to alter the menus draw() to work how you want.

In the context that you get in the draw method, you can access tool_settings.mesh_select_mode which is the three boolean values for the current select mode setting. You then test them to decide if you add the related items.

def draw(self, context):
    layout = self.layout
    pie = layout.menu_pie()
    sel_mode = context.tool_settings.mesh_select_mode
    if sel_mode[0]: # vertex on
        pie.operator('mesh.remove_doubles')
        pie.operator('mesh.merge')
        if not sel_mode[1]:
            # only vert select - don't show if edge sel is also active
            pie.operator('mesh.bevel', text='Vertex Bevel').vertex_only=True
    if sel_mode[1]: # edge on
        pie.operator('mesh.mark_seam')
        pie.operator('mesh.edge_rotate').use_ccw=False
        pie.operator('mesh.bevel', text='Edge Bevel').vertex_only=False
    if sel_mode[2]: # face on
        pie.operator('mesh.flip_normals')
        pie.operator('mesh.inset')
        pie.operator('mesh.poke')


Possible to control text color in the text editor?

So @David's comment I think points you in the right direction, but maybe it can be made a little simpler.

Basically you can give individual characters (or words, or sentences, etc.) different materials (i.e. material indexes).  Each material can, obviously, vary not only in color but any attribute you can put into a material.

So, with the text object below, in edit mode I highlight the characters I wish to give a new material.

You can add a new material slot if you need one, create a new material if you need one, etc., but at the end of the day all you need to do to assign the selected text to the chosen material slot is to click the "Assign" button.

You've then got text with different materials!


Deform the mesh by armature located aside the mesh

Not exactly what you asked, but this could achieve a similar effect: set two identical armatures, one inside the object performing the deform, one "external"  (aside) driving the deform, each internal bone connected to its external peer through copy rotation constraints...

example file:


Is there still the material override feature within render layers in Blender 2.8?

The 2.8 version is not released yet. Even the developers cannot be absolutely sure about how everything is going to be when it's finished. Ability to override materials per render layer is an essential feature. Even though nothing can be said with absolute certainty at this moment it would be very logical to assume this functionality or a way to achieve similar results will remain in one way or another once Blender 2.8 is released. Once again, let's remember the obvious one more time: at this moment Blender 2.8 is not meant to be used for production and is expected to have a lot of serious issues.


Under the shading tab, add an environment texture and set it to closest and connect the node up.


How to model a building with square ground and circular roof

You can start with a sphere.  Create then a cube of the same dimensions.
Use the cube as intersect object in a boolean modifier to create the base shape.

Apply the modifier.

Enter edit mode and delete the bottom half of the object.

Extrude and finesse at will.


How to add edge outlining to transparent objects in bge

You need 2 object, one with a wire transparent material the other with solid material.

You can adjust the alpha in Transparency.

3 And can control with a script, also control the scale.
script.py (example)
from bge import logic

class ObjectsList():
    def __init__(self, controller):
        self.obj = [obj for obj in logic.getCurrentScene().objectsInactive if not obj.name[-1].isdigit()]
        self.objLiner = [obj for obj in logic.getCurrentScene().objectsInactive if obj.name[-1].isdigit()]

    def main(self):
        print(self.obj)
        if len(self.obj) > 0:
            obj = self.obj.pop(0)
            outliner = self.objLiner.pop(0)
            ##creating a solid obj
            mainObj = logic.getCurrentScene().addObject(obj.name)
            ##creating outliner
            outlinerObj = logic.getCurrentScene().addObject(outliner.name)
            ##scaling up
            outlinerObj.localScale = [1.04]*3
            ##changing alpha
            outlinerObj.meshes[0].materials[0].alpha = 0.3
            outlinerObj.suspendDynamics(True)
            outlinerObj.setParent(mainObj)
            print('obj created...')

def main(controller ):
    if not 'init' in controller.owner.getPropertyNames():
        controller.owner['objHandler'] = ObjectsList(controller)
        controller.owner['init'] = True
        return
    controller.owner['objHandler'].main()

Related
Python API (bge object material)
bge.types.KX_BlenderMaterial.alpha
I couldnt found relate documentation about change material type: wire


There isn't one single way to translate your class from Python 2 to Python 3.

You could try using the command-line tool 2to3 to do the translation, but it's not perfect, so you'll need to verify the results.


Tips for better image quality (Video Editing)

Blender uses a fast form of interpolation in the VSE preview, which can give a jagged result.

You don't really have to worry as this won't be in the final render, but it should also go away when you view the preview at 1:1 resolution so nothing needs to be interpolated. You can jump to 1:1 zoom by pressing Numpad 1 in the preview.

Not 1:1:

1:1:


Leftover vertices after parenting to bone - mouth/eyeballs not rigged

You often need to make some corrections once you've parented, typically with independent meshes like eyes, button, etc...

The classic way to fix this is to switch your armature to Pose mode and switch your object to Weight Paint mode then to select the bone to which you want to assign the button/eye, and paint this zone with the brush. Don't forget to deactivate the Limit Selection To Visible option, button on the right of the header menu.

You can also assign the vertices you want to the vertex group they are supposed to be part of in the Properties panel > Data > Vertex Group... When you've parented With Automatic Weights it has automatically created vertex groups and given them the name of the bone that controls them. If you want to add some vertices to a group, select those vertices in your mesh, select the group in the list and press the Assign button.


One solution is to make your arrow as a Curve, and then adding a Build Modifier to it.

It will animate along the direction of the curve (represented by the arrows in Edit mode), but you can check Reverse to change this. Also you can cange the start and length fields to your likes.


Need help flipping multiple objects in a collection as a whole

I might be missing something but the problem seems simple to me.

With your first described attempt you were using Individual Origins.

But I think you want to use Median Point while mirroring, and you'll get the desired result.


This problem shouldn't harm your model in anyway, but if you want to fix it you should do the following:

Click on the drop-down next to the magnet, hot-key = Control + Shift + Tab:

Select the following options: Increment, Scale. It doesn't matter if you have selected Move and/or Rotate:

Click the magnet to activate snapping, hot-key = Shift + Tab. I don't have a picture for this, if you need it you can tell me. Instead of clicking the magnet, you can also hold Control while scaling.


Try something like this.

All I really did was warp the vectors of a couple of Noise Textures by adding the Vectors of Wave Textures using a Vector Math Node. This produces "uneven" wave lines. I made a second of the same, rotated 90 degrees with a Mapping node. so it has that crossed thatch appearance, and then increased the wave distortion slightly, so it doesn't look linear, even, and fake. I also incorporated another Noise Texture to give some underlying bumps. You can see that I lightened both the values by mixing with white before multiplying them together, but even then the effect was almost still too strong - make sure to check your strength/appearance, and mix with white when needed before connecting to the Bump Node. You might be surprised how much more realistic a "slight" effect looks compared to a "deep" one (if that makes any sense)
Lastly, I just took some Ambient Occlusion from the Wave combo and multiplied it with a neutral grey to make the ridges pop slightly more. Have a try and see if it works for you.
If you want to go one farther, you can use yet another Noise Texture to "block" some portions of the wave mix, so it's not so uniform, and thus more realistic. I also elaborated on what I mentioned before about a "slight" bump effect, by mixing the whole mix with white again before the Bump node. I also lightened the color slightly, and increased the roughness (both things also can work to reduce bump effect as well). Here is the final result of the (more complex but improved) new mix:


Add a texture to a cut meshface in animation

As requested In your last comment -

The example you mentioned is much more straight forward as it is a simple dissection and rotation of mesh that's been split in the Z axis...

Create the casing and use the solidify modifier to give it's walls thickness all round, and "apply" the modifier so that thickness becomes permanent mesh.

Give it material and texture at this point.

Duplicate the casing and move the copy to a spare layer (layer 9?).  It's often preferable to show the duplicate as a complete mesh rather than two stationary split sections.  Shading can change at the edges when split and smoothing is also used, whereas the duplicate hasn't been affected.

Slice the original in half vertically, say at 180 degrees and perpendicular to the camera, so you'll have a clear view of any workings that are inside.

A Boolean modifier could do this but I elected to slice this one manually so the results will be predictable and possibly cleaner.

Doing it this way also means there won't be surfaces covering the cross-section gaps between the inner and outer casing walls.
These are easily filled in from Edit mode with the F key.

Once filled they can be textured with your chosen cross-hatch pattern.

The front section's wall gaps probably won't need filling in because you'll only get a glimpse of them as the section is swept away.  (a matter of choice)

Normally the mechanisms within would be left intact and working, probably in a separate layer for convenience.

Animate the front section as required.

-=====-

What I usually do is switch off (make invisible) the front and rear sections of the casing so they don't interfere with the duplicate in Layer 9 which will be visible while everything is stationary.  Keyframe all three in the Outliner's Eye icon at frame 1.

At the frame where the animation starts, switch off the duplicate (eye icon in the outliner) and keyframe that.

At the same frame switch the front and rear sections on - keyframe those also.

The front section will be seen to swing out and be swept away, leaving us with the internal view and inner workings.

////////////////    /////////////////    ////////////

ANSWER for the 22 sec mark...

This method just uses a mask which slides right to left and hides only the front of the casing, not the rear.

The casing has to be "parted" front from rear section so masking can differentiate between the two.

As you're requiring edge thickness for the cross hatch pattern, the edge has to be emulated as the front casing is progressively 'peeled back'.  (Masking cuts targets away, edge thickness and all)

A textured plane shaped for the job is placed at the leading edge of the mask and animated to move identically with it.  To this end the mask's keyframes were simply copied to the edge plane.
(Parenting is unavailable because the mask would then render it invisible)

Shapekeys were used to tweak it's width so it appears to be rotating along with the edge of the front casing as it's peeled back, as well as trimming it's ends to the right angle and length over the course of it's travel.

If it's preferred, extra masks shaped accordingly can do most if not all of the trimming functions for you.  Rotating the edge plane physically as the casing is rolled back would take care of perspective.

Example here

Inviso Masks" -  (own term)

... only works with the viewport and rendering with OpenGL as far as I'm aware.

These are simply planes with absolutely no Specular, not much Diffuse, (dull grey) and their Material slot Opacity set to 0.008.  (a tad above the default 0.004 Alpha threshold)

They are also selective and can discriminate between objects with little effort.  Simply parent objects to them.  (child = object to be hidden).

Remove the parenting immediately and use the "Keep Transformation" option in both instances.

To immunize objects from invisibility - simply parent in reverse.  (child = the mask)
Again - remove the parentage immediately and "Keep Transformation"

IMPORTANT - Deselect all objects when checking them out.  Be in Object Mode and Press A

Chroma-key and other forms of selective masking would need some extra imagination and multiple rendering.


Duplication with rotation only on the Z axis

Until 2.79: I use Dupliframes, then I use a Constraint > Limit Rotation for my object, and I click on Limit X and Limit Y.
Since 2.8: See Gorgious solution here.


How to scale the rendered image in composition?

Yes, Blender can scale in the compositor using the Scale nodes seen below. Pipe the image into a Scale node, then from the Scale node into a Composite output node. If you have "Compositing" checked on in the Rendering tab of the Properties pane, then each frame will be modified and then saved out as usual.

You can also use a File Output node to save out different files in addition to the final Composite, if you want.

Note that in Absolute Mode for the Scale node, you need to input the final image size you're after, not a ratio, so if you want a full HD, you should input 1920 for X, 1080 for Y.


Using this texture (https://freepbr.com/materials/polished-granite-top-pbr-material/) and this node configuration

you can get something like this (you'll need some minor fix, but feel free to try and comment this answer to get further support)

Texture coordinate: this node is useful to tell how the texture should be placed on the mesh (UV setting refers to how the mesh is unwrap in 2d)
mapping: this node is used to scale the texture, rotate or move it
texture image: you choose the image you want to use to "colorize" the mesh
color ramp: this is used here only cause the original texture is white with black dots and you need black texture with white dots. You can control black and white stops to find best results
principled BSDF: this is a shader that contains some attributes to tell blender engine how to render the "colors"
material output: this is mandatory node used to tell Blender that all the settings are applied to the surface of the object


How can you split an edge in 3 or more edges?

First of all, go to Edit Mode and select the edge you want to split, then click the Subdivide button (step 1 in the picture below) and adjust the number of cuts in the panel that appears below (step 2). Also make sure you don't do anything else before adjusting the number of cuts, or the panel will disappear because Blender doesn't store that kind of information in its history, so even if you do Ctrl+Z the edge will return as it was before subdividing but the panel will not reappear and you'll have to do the procedure again.


Can Blender Render on Systems without a GUI?

Yes, this Blender supports this feature, which is frequently used on render-farms.

For reference, in Blender this is known as background mode.

I've had success rendering on a Linux cluster using SGE. Here, I render the first 1500 frames of an animation:

$ for n in `seq 1 1500`; do qbatch blender --background myblend.blend -x 1 -f $n; done

(note qbatch is just a script that submits a regular command line invocation to SGE for distribution to a compute node, so it's the stuff between "qbatch" and "done" that you're probably interested in)

Depending on the dynamics of your system, you may want to batch your renders differently, but you can adapt what I used.

Here is a page that describes some useful command line options: https://docs.blender.org/manual/en/dev/advanced/command_line/render.html


EDIT 2: FIX

Ok After some crazy amount of testing I found the culprit :D

In the render layer section, you have to check in EVERY render layer "use Surfaces".
If unchecked, you will get this strange transparent section in GPU Mode.
And in CPU mode it will even cause a crash to desktop.

In my opinion this crash is even worth a bug report.


Probably a normal issue. Select the entire mesh with A and then press Shift N to recalculate the normals.


It's known problem in blender. And BF working with it. Look how this will be look like in 2.8, in Eevee:

But now. You can switch render engene to Blender Game, and change Alpha Blend type to Alpha Anti-aliasing:

It looks better.


It won't slow things down.

However, Blender's default settings may not be good for such a large piece.

Especially the viewport and camera clippings settings (these settings define the minimal and maximum distances rendered). The End clipping is quite small by default so if you happen to have your objects kind of cut in far distance, this is why.

You will find the viewport clipping settings in the View panel of the options bar (N) of the viewport, and the camera clipping settings are in the Camera tab (select the camera first), in the Lens panel :


The exporter's wiki page contains all necessary information to get you started in several languages,

It is possible to edit the options of where and how to write the pov file, when "AUTO"(car icon) is unchecked in render tab's INI Options panel

If you uncheck Delete file option, you will be able to open the rendered pov file from the temporary folder, or the folder of your choice if any has been specified.

Some topics include command line switches to pass parameters as you would through the command prompt when launching POV from a terminal or from ini files.


AN Loft Splines not observing vertex hooks

Unfortunately, this is not possible in Animation Nodes. Jacques Luke (AN Developer) said the following about this particular issue:

  Blender does not (to my knowledge) allow scripts to get the result of curve modifiers in a way that is suitable for AN. The only possible way to see atm is that AN makes a copy of the curve object, applies all modifiers, hopes that the result is only a single spline, loads that spline into AN and removes the copied spline. This would have to happen on every recalculation. While the performance might be good enough when the spline is small, there are other problems when using this approach. Specifically it requires AN to use certain operators that should not be used during rendering.

What you can do however, is implement the hook modifier inside animation Nodes instead. Below, I will explain a potential way to do this.

Animation Nodes Hooks

First, I will rename all the hooks, where the name is "Hook.n" where n is the index of the spline point it should control. Then I will loop over the spline points of the spline, check if an object exist by the name "Hook.n" where n is the index, If I find an object by that name, I append the hook location, otherwise, I append the spline point location. What we end up with is the new locations of the spline points:

And now we can safely regenerate the spline with the new locations:

Hooks are however defined as an offset from their initial location, the same can be done in Animation Nodes using ID Keys, but I will leave that to you.

Animation Nodes Issues

StackExchange is no place to report Animation Nodes bugs, Github issues in the AN repository is the place to share bugs in:

https://github.com/JacquesLucke/animation_nodes/issues/new


How to make a Copper/Rose Gold smudge material?

I would just use a simple principled shade.

Slide the metallic and specular (forgot to change specular) close to 1.

Choose a rose gold color and use a texture in your roughness. I put two options, a procedural way (noise texture stretched with mapping node) but I think an actual texture image looks better.

Use an HDRI so you get more realistic reflections.


My UV layout is distorted compared to the geometry of my object

When you unwrap an object and then add an image, the UV unwrapping will be adjusted to the aspect ratio of the image. So if you unwrap in the default square UV area and then open a rectangular image your UVs will be stretched/squashed.

Blender has an option when unwrapping called 'Correct Aspect' which should fix your exact problem. 'Correct Aspect' looks at the selected image node in the object's material and uses that to remove this stretching/squashing effect. However - it doesn't seem to like the ngon at the centre of that circle you are unwrapping.

So:

Select the ngon and press Ctrl+F> Poke Faces to triangulate it.
Press U to unwrap and, immediately after unwrapping, open the toolbar (T) in the 3D view and turn on 'Correct Aspect' or press F6 to access the same options.


Blender 2.82a in Texture Paint mode Paint Mask doesn't show wireframe

In the Properties Editor under the Object Properties panel, You can turn on the Wireframe and All Edges options there to get wireframe over your texture paint.


Can you Weight Paint differently on Linked Duplicates?

Select your object, go in Edit mode and assign a vertex group to the faces that are supposed to emit the particles. Then in the Properties panel > Particles, create your particle settings and in the Vertex Groups submenu > Density field, choose the vertex group you've created.

Link-duplicate your object (AltD), go in Edit mode and assign a new vertex group to the faces that are supposed to emit the particles on this second object. Then in the Vertex Groups submenu > Density field, choose this new group.

The objects are still linked but the particles emission will happen on 2 different parts.


You could create a cube, subdivide and smooth it:

Give it several shapekeys:

In Object mode, select a shapekey, push its Value up to 1 and sculpt:

Sculpt the other shapekeys, animate them:

Or you could create your mesh with metaballs that you convert to mesh:

Then give it a Displace modifier with a Cloud texture and an empty as Object:

In the Displace modifier, save several versions As Shapekeys:

Now you can animate the shapekeys, also sometimes do some Shrink/Fatten to inflate the cloud a bit:


Possible to create new Application Handler?

The Blender/Python API can’t (yet)...
  ...
  - Define callbacks or listeners to be notified when data is changed.

Source: API docs

App handlers can't be created with Python, they need to the coded in C. The fact that registering arbitrary event callback isn't supported suggests that such an event driven design is not intended in Blender.


Unfortunately, importing blender materials into Unity is still a fantasy. But, the best thing you can do is to bake the textures in blender and then use that as the image texture in Unity.
Google how to bake textures and your all set :)


How to fix shading issue on a flat face?

I found a solution to this particular problem of mine. After applying the bevel modifiers i inset the faces which where previously giving me issues. This made it near impossible to see when rendered but probably not perfect.


Converting the Sponza Palace ceiling into square-like faces

I would just go edit mode and do some manual cuts... it is enough to fix just a quarter of the mesh, then use a mirror modifier with X and Y axis enabled to recreate the ceiling.

You have a couple of options to do the cuts:
1. K key is the knife tool, it got some useful extra keys, E to make multiple cuts, C to constraint, Ctrl to snap to to midpoint, SpaceBar to apply... do it from top view
2. J key is vertex connect path, just select endpoints of the arc and press J

first option will result in more perfect squares and second one in a more organic distribution
for the tris I suggest to rotate the edges (Ctrl E > Rotate CW) and repeat with Shift R but you could just use Dissolve Edges

here's a blend with both of this techniques: https://www.dropbox.com/s/v7t730b506t8y30/ceiling.blend?dl=1


How do I turn off "smart" multiple selection? (3ds Max UI preset)

gandalf, that got me pointed in the right direction. ⇧ Shift⎈ Ctrl LMB does it in the Max preset.


Stop object from being displayed on multiple layers?

Press M and select the layer you want it to be on.

Chances are, what you did, was press M and selected multiple layers by holding down Shift