macos – Can I get 2560×1440 scaled resolution on a 4k screen using Mac OS El Capitan?

I have a Macbook Air still on El Capitan. I recently plugged a 4k monitor into it using a and it is offering me (even with the option-click) scaled resolution no higher than 1080p. I would like to try 1440p on this monitor.

I suspect El Capitan might be the problem here (and if I update, maybe the problem will go away). However, I’m not assured that this is my only path. Does anyone know how I can get 2560x1440p to show up as a scaled resolution for my monitor?

shaders – OpenGL translation based on “scaled” pixels? (Not physical pixels)

My (2D!) game runs in a “scaling mode” so to speak, and I’ve yet to find anyone asking this question anywhere. Basically, I want to achieve a sort of “scaling algorithm” whether graphics are translated based on some “virtual pixel” multiplier.

Essentially, if the game is running natively at 624×240, then everything is translated exactly 1 physical pixel. But, if the game has been scaled 2 or 3 times, then I need the graphics to be translated by 2 or 3 pixels, respectively, because the graphics are scaled. Basically, each pixel should move 1 pixel multiplied by the scaling factor. In other words, a 64×64 pixel Sprite would move 3 pixels to the right when scaled 3 times. If this sprite starts at 100×50, then it’s new position would be 103×50, not 101×50. This is the issue I cannot overcome. I have tried something like this: model = glam::mat4(<identity>, glm::vec3(pos.x + scale, pos.y + scale, 0.f)); -> everything still moves 1 physical pixel.

I asked on the gamedev subreddit, but no one was able to help me out, primarily because either I probably misunderstood what they were saying, or they were quite vague in what they were saying. One person was talking about scaling the vertex positions in the vertex shader, then mentioned using GL_SHORT when calling glVertexAttribPointer but I was trying for over an hour and couldn’t make GL_SHORT work to save my life.

I tried using glViewport, but everything is still translated by physical pixels. Anyone have any ideas? Any insights? I also tried framebuffers but they ended up being a huge pain for what I want to do, that they didn’t seem worth it to me.

progress – In terms of levels and gamification what would be the best option between infinite points and scaled levels?

Infinite points or Scaled levels

I’m wondering what would be the best option UX-wise in terms of user levels and gamification for a contribution app :

Are the users more sensible about a goal that would not be visible (like in Stack exchange, there is no final level, only points till’ infinity) or are they more sensible about achieving levels over levels?

I would say that the first option, Infinite points would be simpler to implement and would be understandable for everyone.

But I’m concerned about this “getting rewards on a regular basis” option Scaled levels.

What would be your point on an issue like this one, UX-wise?

optimization – How to minimize a function with two bad scaled unknown variables?

In my research, I have obtained an equation with two unknown variables. I have tried many optimization methods, both gradient-based and gradient-free ones, but unsuccessful. Maybe due to the fact that two variables are badly scaled. The equation f(x,y) is:
(1./364500000.)*exp(300.x)(405000.*exp(900.*x)*x^2-900.*exp(900.*x)*x+exp(900.x)-1)/(x^3y)-5.01693568940709373E-005=0
I know the solution is x=0.004 and y=400000. But what optimization method is able to find these two results? Is rescaling needed? Thanks in advance.
Kind regards
Farzad

google sheets – Twenty One Pilots Scaled And Icy T-Shirts?

Twenty One Pilots Scaled And Icy T-Shirts – If you are a true lover of Twenty One Pilots,Hope you’d like this Gregory Porter All Rise T-Shirt.Special Run of This
Twenty One Pilots Scaled And Icy Shirts produced just for you.
Grab Twenty One Pilots Scaled And Icy T-ShirtToday.
Here you can get yourTwenty One Pilots Scaled And Icy Shirts.

Grab Now Your Twenty One Pilots Scaled And Icy T-Shirts:
https://moteefe.com/twenty-one-pilots-scaled-and-icy-t-shirts

Twenty One Pilots Scaled And Icy T-Shirts

nt.number theory – Scaled Riemann zeta function with no zero in the critical strip

Prime numbers are denoted as $p_,p_2,dots$ with $p_1=2$. The modulus of a complex number $s$ is denoted as $|s|$. Finally, $S$ denotes the right half of the critical strip, defined by $frac{1}{2}<Re(s)<1$.

Let us assume that one can find a product of the form

$$zeta^*(s)=prod_{k=1}^inftyfrac{tau_k(s)}{1-p_k^{-s}},$$

converging in $S$, but not necessarily if $Re(s)=frac{1}{2}$, thus leaving open the possibility that it has zeroes or is undefined on the critical line. Let us further assume that if $sin S$, we have:

  • $tau_k(s)$ is a strictly positive real number
  • $|zeta^*(s)|>0$, thus no zero (in other words, the product converges if $sin S$)
  • $zeta^*(s)$ is smooth enough

Would that imply that the Riemann Hypothesis (RH) is true? I guess the answer is not necessarily. I can not believe that the answer is yes, otherwise (barring some mistakes in my computations), I have found such a function, and I know that there is no way I could prove RH. So I am looking for an answer that explains why it does not necessarily imply that RH is true.

Note that if $tau_k(s)=1$, then $zeta^*=zeta$ is the traditional Riemann zeta function, but then the product representation makes no sense if $sin S$.

Below is my function $zeta^*$ satisfying all the requirements. The methodology to get there can be applied to other Dirichet $L$-functions. It is described in some details in my previous MO question here (not at all intended to prove RH), with the core idea explained in the “Update” section, just below the conclusions. The arguments are not very complicated. Instead, the approach (based on finite products ultimately converging) is somewhat unusual and involves some subtleties, and some luck in the sense that there are some rather unexpected simplifications taking place.

About my re-scaled Riemann zeta product

Let $s=sigma + it$. It is defined using

$$tau_k(s)=Big(1+frac{2cos(tlog p_k)}{p_k^sigma + p_k^{-sigma}}Big)^{-frac{1}{2}}.$$

It results in

$$|zeta^*(s)|^{-2} = Big{prod_{k=1}^infty Big(1+frac{1}{p_k^{2sigma}}Big)Big}
cdot Big{prod_{k=1}^infty Big(1-frac{4cos^2(tlog p_k)}{p_k^{2sigma}+p_k^{-2sigma}+2}Big)Big}.$$

The above product converges if $sin S$, but not always (if ever) when $Re(s)=frac{1}{2}$, and never if $Re(s)<frac{1}{2}$. And of course, due to the infinite product representation, $zeta^*(s)$ can never vanish if $sin S$. Again, details are available here.

plotting – Scaled Axis when drawing circle

Use the option AspectRatio -> Automatic:

Plot[{}, {x, 0, 1}, 
 Epilog -> {Red, Circle[{.5, .5}, .5], Red, 
   Line[{{0, .993}, {.5, .993}}], Green, 
   Line[{{.5, .993}, {.5, .5}}]}, 
 AspectRatio -> Automatic]

enter image description here

More straightforward way to get the same result is to use Graphics:

Graphics[{Red, Circle[{.5, .5}, .5], 
  Red, Line[{{0, .993}, {.5, .993}}],
  Green, Line[{{.5, .993}, {.5, .5}}]}, 
 Axes -> True]

enter image description here

rendering – How do I map a point from the original picture to a scaled version picture?

I’m trying to implement supersampling antialiasing in my software renderer.And per my understanding,I need first render everything to a 4x- scaled buffer then average every four pixels’ colors of that 4x-scaled
buffer to a smaller 1X buffer.However,supersampling should be transparent to user,user would only pass in vertices in that 1X-scaled smaller buffer.And my question is how to map the vertices from a smaller buffer to a scaled buffer?

some definition of my buffers:

    Surface     sysBuffer;
    Surface     superSamplingSysBuffer;
    static constexpr unsigned int ScreenWidth = 400;
    static constexpr unsigned int ScreenHeight = 300;
    static constexpr bool superSampling = true;
    static constexpr unsigned int superSamplingNum = 4;

Initialization:

    Graphics::Graphics(HWNDKey& key)
    :
    sysBuffer(ScreenWidth, ScreenHeight),
    superSamplingSysBuffer(ScreenWidth* superSamplingNum, ScreenHeight* superSamplingNum)

Composition of a single frame:

void Game::ComposeFrame(){
    gfx.DrawLineBresenham(0, 200, 200, 200, Color{ 255,255,255 });
}

Line Drawing:

void Graphics::DrawLineBresenham(float x1, float y1, float x2, float y2, Color c) {

    if (Graphics::superSampling) {
        x1 *= Graphics::superSamplingNum;//MY attempts to mapping points to bigger buffer
        y1 *= Graphics::superSamplingNum;
        x2 *= Graphics::superSamplingNum;
        y2 *= Graphics::superSamplingNum;
    }

    if (fabs(x2 - x1) < 1e-6) {
        if (y1 > y2)
        {
            std::swap(x1, x2);
            std::swap(y1, y2);
        }

        int xInt1 = static_cast<int>((x1 + 0.5f));

        for (; y1 < y2; y1++) {
            PutPixel(xInt1, int(y1 + 0.5f), c);
        }
        return;
    }
    else {
        float k, d;
        k = (y2 - y1) / (x2 - x1);
        if (k >= 1.f) {
            if (y1 > y2)
            {
                std::swap(x1, x2);
                std::swap(y1, y2);
            }
            d = 1.f - 0.5f * k;
            for (; y1 < y2; y1++) {
                PutPixel(int(x1 + 0.5f), int(y1 + 0.5f), c);
                if (d >= 0.f)
                {
                    x1++;
                    d += (1.f - k);
                }
                else {
                    d += 1.f;
                }
            }
            return;
        }
        if (0.f <= k && k < 1.f) {
            if (x1 > x2)
            {
                std::swap(x1, x2);
                std::swap(y1, y2);
            }
            d = 0.5f - k;
            for (; x1 < x2; x1++) {
                PutPixel(int(x1 + 0.5f), int(y1 + 0.5f), c);
                if (d < 0.f) {
                    y1++;
                    d += (1.f - k);
                }
                else {
                    d -= k;
                }
            }
            return;
        }
        if (k >= -1.f && k < 0.f) {
            if (x1 > x2) {
                std::swap(x1, x2);
                std::swap(y1, y2);
            }
            d = -0.5f - k;
            for (; x1 < x2; x1++) {
                PutPixel(int(x1 + 0.5f), int(y1 + 0.5f), c);
                if (d > 0.f) {
                    y1--;
                    d -= (1.f + k);
                }
                else {
                    d -= k;
                }
            }
            return;
        }
        if (k < -1.f) {
            if (y1 < y2) {
                std::swap(x1, x2);
                std::swap(y1, y2);
            }

            d = -1.f - 0.5f * k;

            for (; y1 > y2; y1--) {
                PutPixel(int(x1 + 0.5f), int(y1 + 0.5f), c);
                if (d < 0.f) {
                    x1++;
                    d -= (1.f + k);
                }
                else {
                    d -= 1.f;
                }
            }
            return;
        }
    }


}

Finally downsampling:

void Graphics::EndFrame()
{
    HRESULT hr;


    if (superSampling) {//AVERAGING COLORS
        float sum(4) = { 0 };
        for (int i = 0; i < ScreenWidth; i++) {
            for (int j = 0; j < ScreenHeight; j++) {
                for (int k = i * superSamplingNum; k < (i * superSamplingNum + (superSamplingNum)); k++) {
                    for (int l = j * superSamplingNum; l < (j * superSamplingNum + (superSamplingNum )); l++) {
                        Color temp = superSamplingSysBuffer.GetPixel(k, j);
                        sum(0) += (float)temp.GetR();
                        sum(1) += (float)temp.GetG();
                        sum(2) += (float)temp.GetB();
                        sum(3) += (float)temp.GetA();
                    }
                }

                sum(0) *= 0.25f;
                sum(1) *= 0.25f;
                sum(2) *= 0.25f;
                sum(3) *= 0.25f;
                Color result((unsigned char)sum(3), (unsigned char)sum(0), (unsigned char)sum(1), (unsigned char)sum(2));
                sysBuffer.PutPixel(i, j, result);
                sum(0) = 0.f;
                sum(1) = 0.f;
                sum(2) = 0.f;
                sum(3) = 0.f;

            }
        }
    }
    //SOME DX11 irrelevent things
    // lock and map the adapter memory for copying over the sysbuffer
    if (FAILED(hr = pImmediateContext->Map(pSysBufferTexture.Get(), 0u,
        D3D11_MAP_WRITE_DISCARD, 0u, &mappedSysBufferTexture)))
    {
        throw CHILI_GFX_EXCEPTION(hr, L"Mapping sysbuffer");
    }
    // perform the copy line-by-line
    sysBuffer.Present(mappedSysBufferTexture.RowPitch,
        reinterpret_cast<BYTE*>(mappedSysBufferTexture.pData));
    // release the adapter memory
    pImmediateContext->Unmap(pSysBufferTexture.Get(), 0u);

    // render offscreen scene texture to back buffer
    pImmediateContext->IASetInputLayout(pInputLayout.Get());
    pImmediateContext->VSSetShader(pVertexShader.Get(), nullptr, 0u);
    pImmediateContext->PSSetShader(pPixelShader.Get(), nullptr, 0u);
    pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    const UINT stride = sizeof(FSQVertex);
    const UINT offset = 0u;
    pImmediateContext->IASetVertexBuffers(0u, 1u, pVertexBuffer.GetAddressOf(), &stride, &offset);
    pImmediateContext->PSSetShaderResources(0u, 1u, pSysBufferTextureView.GetAddressOf());
    pImmediateContext->PSSetSamplers(0u, 1u, pSamplerState.GetAddressOf());
    pImmediateContext->Draw(6u, 0u);

    // flip back/front buffers
    if (FAILED(hr = pSwapChain->Present(1u, 0u)))
    {
        throw CHILI_GFX_EXCEPTION(hr, L"Presenting back buffer");
    }
}

Supersampling off:
Supersampling off

Supersampling on:

enter image description here

Disired effect:
enter image description here