<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="https://community.arm.com/utility/feedstylesheets/rss.xsl" media="screen"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/"><channel><title>Shawn Chang's Activities</title><link>https://community.arm.com/members/shawn-chang</link><description>Shawn Chang's recent activity</description><dc:language>en-US</dc:language><generator>Telligent Community 10</generator><item><title>Processing order of vertices and fragments in arm gpu</title><link>https://community.arm.com/developer/tools-software/graphics/f/discussions/48388/processing-order-of-vertices-and-fragments-in-arm-gpu</link><pubDate>Tue, 29 Dec 2020 09:19:23 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:3863ad76-08f6-409e-aeeb-1d45d9de6716</guid><dc:creator>Shawn Chang</dc:creator><description>&lt;div class="UdTY9 BwTYAc"&gt;
&lt;div class="kO6q6e"&gt;&lt;/div&gt;
&lt;/div&gt;
&lt;div class="dePhmb"&gt;
&lt;div class="eyKpYb"&gt;
&lt;div class="J0lOec"&gt;&lt;span class="VIiyi" lang="en"&gt;&lt;span class="JLqJ4b ChMk0b"&gt;&lt;span&gt;When the ARM GPU processes vertices and fragments, in what order are they distributed and processed?&lt;/span&gt;&lt;/span&gt; &lt;span class="JLqJ4b ChMk0b"&gt;&lt;span&gt;Vertices are in index order?&lt;/span&gt;&lt;/span&gt; &lt;span class="JLqJ4b ChMk0b"&gt;&lt;span&gt;What about fragment?&lt;/span&gt;&lt;/span&gt;&lt;span class="JLqJ4b"&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span class="JLqJ4b ChMk0b"&gt;&lt;span&gt;Can we try to control the order of the index on the cpu side to improve the efficiency of the GPU?&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;
&lt;div class="J0lOec"&gt;&lt;span class="VIiyi" lang="en"&gt;&lt;span class="JLqJ4b ChMk0b"&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;
&lt;div class="J0lOec"&gt;&lt;span class="VIiyi" lang="en"&gt;&lt;span class="JLqJ4b ChMk0b"&gt;&lt;span&gt;For example: Does the optimization of the link below improve the gpu of arm? If there is an improvement, what features of the GPUs they use?&lt;span class="JLqJ4b"&gt; &lt;/span&gt;&lt;a href="https://github.com/zeux/meshoptimizer"&gt;github.com/.../meshoptimizer&lt;/a&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>varying vs computation performance in fragment shader</title><link>https://community.arm.com/developer/tools-software/graphics/f/discussions/48387/varying-vs-computation-performance-in-fragment-shader</link><pubDate>Tue, 29 Dec 2020 08:14:54 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:80b1121a-6a3e-4ced-99f4-b15047c0cedc</guid><dc:creator>Shawn Chang</dc:creator><description>&lt;p&gt;I want to know the cost of varying or the cost of calculation, which is greater？&lt;/p&gt;
&lt;p&gt;Take the following example as an example:&lt;br /&gt;A*(1-factor), the factor is calculated in the vertex shader, and the factor will be passed to the fragment shader as varying. In order to achieve the same effect, there are the following two solutions:&lt;br /&gt;1. A is the uniform of the vertex shader, A* (1-factor) is calculated in the vertex shader, and the result is passed to the fragment shader as a varying, and fragment shader uses the result directly - in this case, the main overhead should be varying interpolation.&lt;br /&gt;2. A is the uniform of the fragment shader, A* (1-factor) is calculated in the fragment shader, and then fragment shader directly uses the result of the calculation - in this case, the main cost should be the calculation cost in fragment shader.&lt;/p&gt;
&lt;p&gt;For the above two solutions, which performance is better? Also, where can I find the varying interpolation efficiency data of arm&amp;#39;s GPU? For example: How many floats can by interpolated in a cycle?&lt;/p&gt;
&lt;p&gt;&lt;/p&gt;
&lt;p&gt;&lt;pre class="ui-code" data-mode="c_cpp"&gt;// solution 1:
uniform float A;
varying float result;
varying float factor;
void vs()
{
factor = ...;
result = A * (1-factor);
}

void fs()
{
 // directly uses result to other computations
}

// solution 2:
varying float factor;
void vs()
{
factor = ...;

}

uniform float A;
void fs()
{
// ...
result = A * (1-factor);
// ...
}&lt;/pre&gt;&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item></channel></rss>