lighting – What exactly is causing the quality difference between these two photographs?

Here is a photo of 2 individuals: my friend and a male model (right). Both of them are clicked in daylight. I get it that the background on the left picture is very bad but that cannot be the only reason why there’s such a big quality difference between these two! The costume? Or is it the camera?

PS: I’m an absolute newbie to the world of photography so PLEASE guide me!

enter image description here

Sharepoint List Threshold Limit Causing the sharepoint designer workflow to Suspend

One of the task lists which was used in designer workflow reached the threshold limit and because of which the workflows are suspending with the below error.

RequestorId: f307e5c6-0c50-b022-0000-000000000000. Details: An unhandled exception occurred during the execution of the workflow instance. Exception details: System.ApplicationException: HTTP 500 {“error”:{“code”:”-2147024860, Microsoft.SharePoint.SPQueryThrottledException”,”message”:{“lang”:”en-US”,”value”:”The attempted operation is prohibited because it exceeds the list view threshold.”}}}

There is a line in the workflow where it fetches the assignedTo field with taskname filter condition and the same exact line is throwing the above error.

Can someone please suggest to me how to overcome this error without increasing the threshold limit because the list can hold upto 30 million items as Microsoft document.

8 – Cron Tasks not running in background, causing pages to take forever to load

We recently upgraded to D8 and I have been experiencing weird issues with Cron. Specifically, whenever the Cron is running, web pages are taking forever to load because cron is running some JS on the front end of any page you attempt to load. Specifically, it appears to be a timeout method that is holding up the page load.

NOTE: I will update this post and provide the exact JS file and function that is running on the front end the next time it happens to me. At the time of writing, cron wasn’t running and therefore I couldn’t inspect the web page to get the running method

I know it’s not the CPU on the server because when cron was running it never got above 20% CPU utilization.

Isn’t cron suppose to run in the background? Why would cron have a JS file being executed on every page, causing any page not to load until cron finishes?

windows 10 – partmgr.sys causing BSoD – how do I fix it?

Please see this Microsoft Article.

oxca bugcheck

The PNP_DETECTED_FATAL_ERROR bug check has a value of 0x000000CA. This
indicates that the Plug and Play Manager encountered a severe error,
probably as a result of a problematic Plug and Play driver.

Invalid PDO: An API which requires a PDO has been called with random
memory, or with an FDO, or with a PDO which hasn’t been initialized.

(An uninitialized PDO is one that has not been returned to Plug and
Play by QueryDeviceRelation or QueryBusRelations.)

In addition to checking Plug and Play (what devices are you adding), is there a replacement for partmgr.sys or the device that is using it.

What’s causing the shadow running down the side of my photographs

Using my Canon IV S2 I get a straight vertical shadow on the right of the picture ( It occupies about half an inch down the short side of 6X4 print).I assume it’s the cloth shutter edge trailing but how come it’s only happening at 1/125th sec and not at slower or faster speeds ? I’ve put a couple of rolls of film through the camera to test all of settings.

directory – WordPress hosted on subfolder of domain causing customizer to constantly refresh and is requesting jquery from root domain

So I have wordpress installed in a subfolder of my domain: https://example.com/blog

To do this I am reverse proxying ngnix (main app) to apache (wordpress server) and everything is going great.

One weird problem I noticed though is when I go to the customizer it keeps refreshing constantly. It looks like its trying to request jquery from the root https://example.com even though:

Site Address (URL)
WordPress Address (URL)

Are both set to: https://example.com/blog

Any ideas?

current_user_can() causing critical error

I am writing a function to add a link to the Media Library in the admin menu on front end:

function add_media_link_to_admin_menu( $wp_admin_bar ) {

    // add Media Library to admin menu
        $wp_admin_bar->add_menu( array(
            'parent' => 'appearance',
            'id'     => 'media-library',
            'title'  => 'Media Library',
            'href'   => '/wp-admin/upload.php',
        ) );
        
}

// restrict to only users who can upload media
if ( !current_user_can( 'upload_files' ) ) {

    add_action( 'admin_bar_menu', 'add_media_link_to_admin_menu', 999 );

}

Without the "if ( !current_user_can( ‘upload_files’ ) ) {" the function works fine. But with the if statement, I get a critical error.

Am I missing something? I just want to check if user can upload files. If not, they don’t need the Media Library link.

Thanks,
Chris

c++ – Unreal Engine Procedural Mesh causing crash when rendering chunk size too large

Hey guys im pretty new to unreal but id consider myself a fairly advanced programmer. Im really stuck on rendering my chunks for my voxel game. The implementation is pretty simple and everything works wonders when the chunk sizes are less than 16x16x16. But when i try to render a chunk larger i get a crash.

here is my soruce

   void AVoxelActor::OnConstruction(const FTransform& Transform)
{
    numVoxelsXY = 16;
    numVoxelsZ = 64;

    //create name
    FString string = "Voxel_" + FString::FromInt(chunkXPos) + "_" + FString::FromInt(chunkYPos);
    FName name = FName(*string);

    //create mesh comp and register
    proceduralMeshComponenent = NewObject<UProceduralMeshComponent>(this, name);
    proceduralMeshComponenent->RegisterComponent();

    RootComponent = proceduralMeshComponenent;
    RootComponent->SetWorldTransform(Transform);

    Super::OnConstruction(Transform);

    GenerateChunk(); 
    UpdateMesh();
}



void AVoxelActor::GenerateChunk() {
    m_vBlocks = new VoxelBlock * *(numVoxelsXY);
    for (int i = 0; i < numVoxelsXY; i++) {
        m_vBlocks(i) = new VoxelBlock *(numVoxelsXY);
        for (int j = 0; j < numVoxelsXY; j++) {
            m_vBlocks(i)(j) = new VoxelBlock  (numVoxelsZ);
            
        }
    }
}



void AVoxelActor::UpdateMesh() {

    
    TArray<FVector> Vertices;
    TArray<int32> Triangles;
    TArray<FVector> Normals;
    TArray<FVector2D> UVs;
    TArray<FProcMeshTangent> Tangents;
    TArray<FColor> VertexColors;

    int32 elementID = 0;


    bool lDefault = true;

    for (int x = 0; x < numVoxelsXY; x++) {

        for (int y = 0; y < numVoxelsXY; y++) {

            for (int z = 0; z < numVoxelsZ; z++) {



                //Check if block exists else dont render anything
                if (m_vBlocks(x)(y)(z).IsActive() == false) { // Don't create triangle data for inactive blocks
                    continue;
                }

                //check faces to see if they are visible or not to render
                bool lXNegative = lDefault;
                if (x > 0) lXNegative = !m_vBlocks(x - 1)(y)(z).IsActive();
                bool lXPositive = lDefault;
                if (x < numVoxelsXY - 1) lXPositive = !m_vBlocks(x + 1)(y)(z).IsActive();
                bool lYNegative = lDefault;
                if (y > 0) lYNegative = !m_vBlocks(x)(y - 1)(z).IsActive();
                bool lYPositive = lDefault;
                if (y < numVoxelsXY - 1) lYPositive = !m_vBlocks(x)(y + 1)(z).IsActive();
                bool lZNegative = lDefault;
                if (z > 0) lZNegative = !m_vBlocks(x)(y)(z - 1).IsActive();
                bool lZPositive = lDefault;
                if (z < numVoxelsZ - 1) lZPositive = !m_vBlocks(x)(y)(z + 1).IsActive();



                //create mesh and vertices info for faces of cube that are visible
                int triangle_num = 0;
                for (int i = 0; i < 6; i++)
                {

                    Triangles.Add(bTriangles(0) + triangle_num + elementID);
                    Triangles.Add(bTriangles(1) + triangle_num + elementID);
                    Triangles.Add(bTriangles(2) + triangle_num + elementID);
                    Triangles.Add(bTriangles(3) + triangle_num + elementID);
                    Triangles.Add(bTriangles(4) + triangle_num + elementID);
                    Triangles.Add(bTriangles(5) + triangle_num + elementID);
                    triangle_num += 4; // add 4 vertices to next triangle

                    switch (i)
                    {
                        case 0: {
                            if (lZPositive) {
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));

                                Normals.Append(bNormals0, UE_ARRAY_COUNT(bNormals0));
                            }
                                break;
                            
                        }

                        case 1: {
                            if (lZNegative) {
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));

                                Normals.Append(bNormals1, UE_ARRAY_COUNT(bNormals1));
                            }
                                break;
                            
                        }

                        case 2: {
                            if (lYPositive) {
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));

                                Normals.Append(bNormals2, UE_ARRAY_COUNT(bNormals2));
                            }
                                break;
                        
                        }

                        case 3: {

                            if (lYNegative) {
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));

                                Normals.Append(bNormals3, UE_ARRAY_COUNT(bNormals3));
                            }
                                break;
                            
                        }
                        case 4: {
                            if (lXPositive) {
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector((voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));

                                Normals.Append(bNormals4, UE_ARRAY_COUNT(bNormals4));
                            }
                                break;
                        }
                        case 5: {
                            if (lXNegative) {
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), (voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), -(voxelSize / 2) + (z * voxelSize)));
                                Vertices.Add(FVector(-(voxelSize / 2) + (x * voxelSize), -(voxelSize / 2) + (y * voxelSize), (voxelSize / 2) + (z * voxelSize)));

                                Normals.Append(bNormals5, UE_ARRAY_COUNT(bNormals5));
                            }
                            break;
                        }
                    }
                          UVs.Append(bUVs, UE_ARRAY_COUNT(bUVs));
                          FColor color = FColor(255, 255, 255, i);
                          VertexColors.Add(color); VertexColors.Add(color); VertexColors.Add(color); VertexColors.Add(color);
                    
                }
                elementID += triangle_num;
            }


        }

    }
    proceduralMeshComponenent->ClearAllMeshSections();
    proceduralMeshComponenent->CreateMeshSection(0, Vertices, Triangles, Normals, UVs, VertexColors, Tangents, true);
}

and this is the error i get, also if i turn off the collison generation for the mesh i can generate no problem. This makes me believe that its a performance issue causing the crash but i am completely stuck

Exception thrown at 0x00007FFCAA395092 (PhysX3CookingPROFILE_x64.dll) in UE4Editor-Win64-DebugGame.exe: 0xC0000005: Access violation reading location 0x0000016947772F38.