Yes, you are correct. The uniform value for a sampler refers to the texture unit, not the texture id.

Say I have a template layout saved in template.html.  This template includes a banner, side navigation, content container, and footer. Can I use flask to break up these page elements in such a way that I can have files such as banner.html, sidenavigation.html, etc. and render these different files within template.html?

Is it possible to perform Includes with flask?

How may I initialize multiple PHP variables with a value of zero  simultaneously *without using an array*? I wish to write code that is essentially equivalent to the following:

    $first = 0;
    $second = 0;
    $third = 0;
    $fourth = 0;


Initializing Multiple PHP Variables Simultaneously

I have a question about how to set the texture by `glUniform1i`. I have seen code like below.

    glActiveTexture(GL_TEXTURE0); 
    glBindTexture(GL_TEXTURE_2D, texture0);
    glUniform1i(_textureUniform, 0);
    glActiveTexture(GL_TEXTURE1); 
    glBindTexture(GL_TEXTURE_2D, texture1);
    glUniform1i(_textureUniform, 1);

Does it mean, if I use the number `i` in the `glUniform1i`, then I have to use `glActiveTexture(GL_TEXTURE **i** )`?

set the texture for by glUniform1i

I have a question about how to set the texture by <code>glUniform1i</code>. I have seen code like below.
<pre><code class="hljs language-scss">glActiveTexture(GL_TEXTURE0); 
glBindTexture(GL_TEXTURE_2D, texture0);
glUniform1i(_textureUniform, 0);
glActiveTexture(GL_TEXTURE1); 
glBindTexture(GL_TEXTURE_2D, texture1);
glUniform1i(_textureUniform, 1);
</code></pre>
Does it mean, if I use the number <code>i</code> in the <code>glUniform1i</code>, then I have to use <code>glActiveTexture(GL_TEXTURE **i** )</code>?

I am learning OpenGL from [this tutorial][1].
My question is about the specification in general, not about a specific function or topic.
When seeing code like the following:

    glGenBuffers(1, &amp;positionBufferObject);
    glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

I&#39;m confused about the utility of calling the bind functions before and after setting the buffer data.
It seems superfluous to me, due to my inexperience with OpenGL and Computer Graphics in general.

The man page says that:

&gt; glBindBuffer lets you create or use a named buffer object. Calling glBindBuffer with target set to
       GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER or GL_PIXEL_UNPACK_BUFFER and buffer set to the
       name of the new buffer object binds the buffer object name to the target. When a buffer object is bound to a
       target, the previous binding for that target is automatically broken.

What exactly is the concept/utility of &#39;binding&#39; something to a &#39;target&#39; ? 

  [1]: https://alfonse.bitbucket.io/oldtut/Basics/Intro%20Graphics%20and%20Rendering.html

Concept behind OpenGL&#39;s &#39;Bind&#39; functions

When you are learning 3D programming, you are taught that it&#39;s easiest think in terms of 3 transformation matrices:

   1. *The Model Matrix*. This matrix is individual to every single model and it rotates and scales the object as desired and finally moves it to its final position within your 3D world. &quot;The Model Matrix transforms model coordinates to world coordinates&quot;.

   2. *The View Matrix*. This matrix is usually the same for a large number of objects (if not for all of them) and it rotates and moves all objects according to the current &quot;camera position&quot;. If you imaging that the 3D scene is filmed by a camera and what is rendered on the screen are the images that were captured by this camera, the location of the camera and its viewing direction define which parts of the scene are visible and how the objects appear on the captured image. There are little reasons for changing the view matrix while rendering a single frame, but those do in fact exists (e.g. by rendering the scene twice and changing the view matrix in between, you can create a very simple, yet impressive mirror within your scene). Usually the view matrix changes only once between two frames being drawn. &quot;The View Matrix transforms world coordinates to eye coordinates&quot;.

   3. *The Projection Matrix*. The projection matrix decides how those 3D coordinates are mapped to 2D coordinates, e.g. if there is a perspective applied to them (objects get smaller the farther they are away from the viewer) or not (orthogonal projection). The projection matrix hardly ever changes at all. It may have to change if you are rendering into a window and the window size has changed or if you are rendering full screen and the resolution has changed, however only if the new window size/screen resolution has a different display aspect ratio than before. There are some crazy effects for that you may want to change this matrix but in most cases its pretty much constant for the whole live of your program. &quot;The Projection Matrix transforms eye coordinates to screen coordinates&quot;.

This makes all a lot of sense to me. Of course one could always combine all three matrices into a single one, since multiplying a vector first by matrix `A` and then by matrix `B` is the same as multiplying the vector by matrix `C`, where `C = B * A`.

Now if you look at the classical OpenGL (OpenGL 1.x/2.x), OpenGL knows a projection matrix. Yet OpenGL does not offer a model or a view matrix, it only offers a combined model-view matrix. **Why?** This design forces you to permanently save and restore the &quot;view matrix&quot; since it will get &quot;destroyed&quot; by model transformations applied to it. Why aren&#39;t there three separate matrices?

If you look at the new OpenGL versions (OpenGL 3.x/4.x) and you don&#39;t use the classical render pipeline but customize everything with shaders (GLSL), there are no matrices available any longer at all, you have to define your own matrices. Still most people keep the old concept of a projection matrix and a model-view matrix. **Why would you do that?** Why not using either three matrices, which means you don&#39;t have to permanently save and restore the model-view matrix or you use a single combined model-view-projection (MVP) matrix, which saves you a matrix multiplication in your vertex shader for ever single vertex rendered (after all such a multiplication doesn&#39;t come for free either).

So to summarize my question: Which advantage has a combined model-view matrix together with a separate projection matrix over having three separate matrices or a single MVP matrix?

Why would it be beneficial to have a separate projection matrix, yet combine model and view matrix?

Sometimes I see Integer constants defined in hexadecimal, instead of decimal numbers. This is a small part I took from a GL10 class:

	public static final int GL_STACK_UNDERFLOW = 0x0504;
	public static final int GL_OUT_OF_MEMORY = 0x0505;
	public static final int GL_EXP = 0x0800;
	public static final int GL_EXP2 = 0x0801;
	public static final int GL_FOG_DENSITY = 0x0B62;
	public static final int GL_FOG_START = 0x0B63;
	public static final int GL_FOG_END = 0x0B64;
	public static final int GL_FOG_MODE = 0x0B65;

It&#39;s obviously simpler to define `2914` instead of `0x0B62`, so is there maybe some performance gain? I acutallly don&#39;t think so, since then it should be the compiler&#39;s job to change it.

Why use hexadecimal constants?

I&#39;ve recently ported my volumeraycaster from OpenGL to OpenCL, which decreased the raycaster&#39;s performance by about 90 percent. I tracked the performance decrease to the OpenCL&#39;s imagesampling functions, which are much slower than the respective OpenGL texturesampling functions. By removing the imagesampling functions and the texture sampling functions, both raycaster implementations had about the same speed.
In order to easily bench the functions on different hardware, and to exclude some silly mistakes in the rest of my RTs code, I&#39;ve written a small benchmark which compares the OpenCL sampling speed to the OpenGL sampling speed and tested it on different machines but OpenCL still had just about 10 % of OpenGL&#39;s performance.

The benchmark&#39;s OpenCL HostCode (at least the most important part of it) :

    void OGLWidget::OCLImageSampleTest()
    {
        try
        {
        int size=8;
        float Values[4*size*size*size];
        cl::Kernel kernel=cl::Kernel(program,&quot;ImageSampleTest&quot;,NULL);
        cl::ImageFormat FormatA(CL_RGBA,CL_FLOAT);
        cl::Image3D CLImage(CLcontext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ,FormatA,size,size,size,0,0,Values,NULL);
    
    
        cl::ImageFormat FormatB(CL_RGBA,CL_UNSIGNED_INT8);
        cl::Image2D TempImage(CLcontext, CL_MEM_WRITE_ONLY,FormatB,1024,1024,0,NULL,NULL );
    
    
        kernel.setArg(0, CLImage);
        kernel.setArg(1, TempImage);
    
    
    
        cl::Sampler Samp;
        Samp() = clCreateSampler( CLcontext(), CL_TRUE, CL_ADDRESS_REPEAT, CL_FILTER_LINEAR, NULL);
        kernel.setArg(2, Samp);
    
        QTime BenchmarkTimer=QTime();
        BenchmarkTimer.start();
    
        cl::KernelFunctor func = kernel.bind(queue, cl::NDRange(1024,1024), cl::NDRange(32,32));
        func().wait();
    
        int Duration =  BenchmarkTimer.elapsed();
        printf(&quot;OCLImageSampleTest: %d ms \n&quot;, Duration);
        }
        catch (cl::Error&amp; err)
          {
            std::cerr &lt;&lt; &quot;An OpenCL error occured, &quot; &lt;&lt; err.what()
                      &lt;&lt; &quot;\nError num of &quot; &lt;&lt; err.err() &lt;&lt; &quot;\n&quot;;
            return;
          }
    
    }


OpenCL Kernel:


    void kernel ImageSampleTest( read_only image3d_t CoordTexture, write_only image2d_t FrameBuffer, sampler_t smp)
    {
    int Screenx = get_global_id(0);
    int Screeny = get_global_id(1);
    
    int2 PositionOnScreen=(int2)(Screenx,Screeny) ;
    
    float4 Testvec=(float4)(1,1,1,1);
    for(int i=0; i&lt; 2000; i++)
    {
    Testvec+= read_imagef(CoordTexture,smp, (float4)(0+0.00000001*i,0,0,0)); // i makes sure that the compiler doesn&#39;t unroll the loop
    }
    
    uint4 ToInt=(uint4)( (uint) (Testvec.x), (uint) (Testvec.y) ,(uint)(Testvec.z),1);
    write_imageui ( 	FrameBuffer,  PositionOnScreen,	ToInt ); 
    
    }




OpenGL FragmentShader for a fullscreen quad which has the same amount of fragments as the OpenCL kernel has work items:


    #version 150
    uniform sampler3D Tex;
    out vec4 FragColor;
    
    void main()
    {
    FragColor=vec4(0,0,0,0);
    for(int i=0; i&lt;2000; i++)
    {
    FragColor+= texture(Tex,vec3(0+0.00000001*i,0,0),0);
    }
    }



Furthermore I&#39;ve already tried the following to increase the performance:

-changing workgroup size: no performance increase

-Different Hardware: 280 GTX, 580 GTX, some Fermi Tessla card , all of them had the same abysmal performance in OpenCL vs OpenGL

-Different texture formats (bytes instead of floats), different access patterns and different texture sizes: no increase

-Using a buffer instead of an image for the data and a self written trilinear interpolation function for the sampling in the CL Kernel: Increased the OpenCL performance by about 100 %

-Using a 2D image//texture instead of a 3D image//texture:This increased the OpenCL performance by 100 % although the OpenGL performance didnt change at all.

-Using &quot;nearest&quot; instead of &quot;linear&quot; interpolation: No performance change

This left me wondering:
Did I do a very stupid mistake which decreases the OpenCL performance?
Why is the OpenCL sampling performance so low, although it should use the same texture hardware as OpenGL?
Why is my complex trilinear interpolation function implementation faster than its hardware implementation?
How can I increase the sampling performance in OpenCL so that i can have the same speed as in OpenGL?

Abysmal OpenCL ImageSampling performance vs OpenGL TextureSampling

I have some vertex data. Positions, normals, texture coordinates. I probably loaded it from a .obj file or some other format. Maybe I&#39;m drawing a cube. But each piece of vertex data has its own index. Can I render this mesh data using OpenGL/Direct3D?

Content Type	Original Author	Original Content on Stackoverflow
Question	Yongwei Xing	View Question on Stackoverflow
Solution 1 - Opengl	Tim	View Answer on Stackoverflow

set the texture for by glUniform1i

Opengl Problem Overview

Opengl Solutions

Solution 1 - Opengl

Initializing Multiple PHP Variables Simultaneously

Is it possible to perform Includes with flask?

Attributions