小编use*_*490的帖子

我有一系列使用锚机制的链接:

<div class="header">
    <p class="menu"><a href="#S1">Section1</a></p>
    <p class="menu"><a href="#S2">Section2</a></p>
    ...
</div>
<div style="width: 100%;">
<a name="S1" class="test">&nbsp;</a>
<div class="curtain">
Lots of text
</div>

<a name="S2" class="test">&nbsp;</a>
<div class="curtain">
lots of text
</div>
...
</div>

我使用以下CSS:

.test
{
    position:relative; 
    margin: 0; 
    padding: 0; 
    float: left;
    display: inline-block;
    margin-top: -100px; /* whatever offset this needs to be */
}

它工作正常.但是当然,当我们点击链接时,它会从一个部分跳到另一个部分.所以我希望有一个平滑的过渡,使用某种滚动到选定部分的开头.

我想我在Stackoverflow上读到这对CSS3来说是不可能的,但是我想要一个确认,而且我想知道什么'可能'是解决方案.我很高兴使用JS,但我不能使用jQuery.我尝试在链接上使用on click功能,检索需要显示的div的"垂直位置",但是我没有成功.我还在学习JS,并且不太了解它以便提出我自己的解决方案.

任何帮助/想法将不胜感激.

我怎么知道我的浏览器是否支持SVG 2.0？

(除了尝试一个应该在SVG2中工作并且意识到它不起作用或它有效的功能......？)

似乎有很多关于同一问题的问题,但似乎找不到满意的答案......我有:

1 container (flex) (green)
   2 columns (block) -> left: red, right: orange
      in the left column, I have two divs (green) who follow each other 'menu1''menu2'

这两个菜单本身都包含在div(黑色)中,因此当我旋转它时,两个菜单是垂直的而不是水平的(旋转90度)

目标是让顶部包装器/容器(绿色)占据垂直黑色包装的高度,并使左列包装器不大于旋转的黑色包装器的"宽度".

我得到的内容在以下示例中说明:

https://jsfiddle.net/pg373473/

<div id='container' style='display: flex; border: 3px solid green; flex-direction=row'>
  <div id='leftbox' style='position: relative; display: block; border: 3px solid red'>
    <div id='textwrapper' style='transform-origin: bottom left; transform: translateY(-100%) rotate(90deg); border: 2px solid black;'>
      <div style='border: 3px solid green; display: inline-block'>menu 1</div>
      <div style='border: 3px solid green; display: inline-block'>menu 2</div>
    </div>
  </div> …

我基本上试图了解在光栅化过程中将浮点顶点坐标转换为定点数时GPU是如何工作的.

我读过这篇很好的文章,它解释了很多东西,但它也让我困惑.所以文章解释说因为我们使用32位整数和边缘函数,如下面的形式(a - b)*(c - d) - (e - f)*(g - h),我们被限制在范围[-16384,16383].我理解我们如何得到这个数字.这是我的问题:

1. 首先,这表明顶点坐标可以是负的.然而我不明白的是,技术上在那个阶段顶点坐标在光栅空间中,并且所有三角形之前都应该被剪裁.因此,从技术上讲,x坐标的范围[0,图像宽度]和y坐标的[0,图像高度]应该只有顶点坐标？那么为什么坐标为负？
2. 所以作者解释了范围太有限[-16384,16383].实际上,如果你的宽度为2048像素并使用256个子像素,那么x中点的坐标需要为4194048.这样你就会溢出.作者继续前进,并解释他们是如何在GPU上解决这个问题的,但我根本就没有得到它.如果有人也可以解释它在GPU上的实际操作方式,那就太棒了.

我最近在SE上发布了一个关于下面代码的问题,因为它产生了编译错误.当你实现移动构造函数或移动赋值运算符时,有人会回答这个问题,然后删除默认的复制构造函数.他们还建议我然后使用它std::move()来获得这样的东西:

Image src(200, 200);
Image cpy = std::move(src);

现在这对我有意义,因为在这种情况下你想要使用移动赋值运算符或移动构造函数的事实必须明确.src在这个例子中是一个左值,没有任何东西可以告诉编译器,而不是你实际想要移动它的内容,cpy除非你明确表达std::move.但是,我对此代码有更多问题:

Image cpy = src + src

我没有把副本放在operator +下面,但它是一个简单的类型的重载运算符:

Image operator + (const Image &img) const {
    Image tmp(std::min(w, img.w), std::min(h, img.h));
    for (int j = 0; j < tmp.h; ++j) {
        for (int i = 0; i < tmp.w; ++i) {
            // accumulate the result of the two images
        }
    }
    return tmp; 
}

在这种特殊情况下,我假设操作符以形式返回临时变量,tmp并且当你到达时,将触发移动分配操作符cpy = src + …

我有一个:

std::vector<std::shared_ptr<T>>

我想复制到哪一个

std::vector<std::shared_ptr<const T>>

现在我注意到如果我这样做:

class A
{
public:
    A(const std::vector<std::shared_ptr<int>>& list) : internalList(list.begin(), list.end()) {}
    std::vector<std::shared_ptr<const int>> internalList;
};

它编译得很好(clang ++ std == c ++ 14)但如果我这样做:

class A
{
public:
    A(const std::vector<std::shared_ptr<int>>& list) : internalList(list) {}
    std::vector<std::shared_ptr<const int>> internalList;
};

我觉得很奇怪,当我使用复制构造函数时,它不起作用,因为它无法弄清楚从非const到const的转换？

xxxx.cpp:672:56: error: no matching constructor for initialization of 'std::vector<std::shared_ptr<const int> >'

有人可以解释为什么请,如果我这样做(在构造函数中使用迭代器)是最好的解决方案？

我从事图形应用程序并且一直在使用共享和唯一指针,因为它为我处理内存释放(也称为便利),这可能很糟糕(如果这就是我使用它们的原因).

我最近在Stackoverflow上阅读了一个问题的答案,提到根据B. Stroustrup,通常不应该使用唯一/共享ptrs,而且应该通过值传递参数.

我有一个图形的情况,我认为使用shared_ptr是有道理的,但我想知道专家(我不是C++专家),如果我过度做/思考它,如果是这样,他们会做什么而不是(为了符合C++建议和效率)

我将解决渲染/光线跟踪中出现的一般问题.在这个特殊的问题中,我们有一个对象池(我们将使用三角形进行此解释)和一个结构,为了简化说明,我们将其称为常规3D网格.让我们说在某些时候我们需要将三角形插入到网格中:这意味着我们需要检查每个插入三角形的边界体积是否与网格中的任何单元格重叠,然后是每个重叠的单元格需要保持指向该三角形的指针/引用(供以后使用).一个三角形可能会重叠超过1个单元格,因此它可以被多个单元格引用多次(您可以看到我在shared_ptr这里的位置).

请注意,在网格结构之外,我们不需要三角形池(因此从技术上讲,拥有三角形池的对象是网格,或者更确切地说是网格的单元格).

class Grid
{
    struct Cell
    {
        std::vector<std::shared_ptr<const Triangle>> triList; 
    };
    void insert(triangle*& tri_)
    {
        std::shared_ptr<const Triangle> tri = tri_;
        for (each cell overlapped by tri) {
            // compute cell index
            uint32_t i = ...
            cells[i].triList.push_back(tri);
        }
    }
    Cell cells[RES * RES * RES];
};

void createPoolOfTrianglesAndInsertIntoGrid()
{
    Grid grid;
    uint32_t maxTris = 32;
    Triangle* tris = new Triangles[maxTris];
    // process the triangles
    ...
    // now insert into grid
    for (uint32_t i = …

我已经看到有关如何使用FMA指令集的问题,但在我开始使用它们之前,我首先想知道我是否可以(我的处理器是否支持它们).我找到一篇帖子说我需要查看(在Linux上工作)的输出:

more /proc/cpuinfo

找出来.我明白了:

processor       : 0                                                  
vendor_id       : GenuineIntel                                       
cpu family      : 6                                                  
model           : 30                                                 
model name      : Intel(R) Xeon(R) CPU           X3470  @ 2.93GHz    
stepping        : 5                                                  
cpu MHz         : 2933.235                                           
size            : 8192 KB                                            
physical id     : 0                                                  
siblings        : 4                                                  
core id         : 0                                                  
cpu cores       : 4                                                  
apicid          : 0                                                  
initial apicid  : 0                                                  
fpu             : yes                                                
fpu_exception   : yes                                                
cpuid level     : 11                                                 
wp              : yes                                                
flags           : fpu vme de pse tsc msr …

在3D渲染(或几何形状)中,在光栅化算法中,当您将三角形的顶点投影到屏幕上然后查找像素是否与2D三角形重叠时,通常需要找到深度或z坐标像素重叠的三角形.通常,该方法包括计算三角形的2D"投影"图像中的像素的重心坐标,然后使用这些坐标来内插三角形原始顶点z坐标(在顶点被投影之前).

现在它写在所有教科书中,你不能直接插入顶点的顶点坐标,但你需要这样做:

(抱歉不能让乳胶工作？)

1/z = w0*1/v0.z + w1*1/v1.z + w2*1/v2.z

其中w0,w1和w2是三角形上"像素"的重心坐标.

现在,我正在照顾的是两件事:

• 什么是表明插值z不起作用的正式证明？
• 什么是证明1/z做正确的事情的正式证明？

为了表明这不是家庭作业;-)而且我自己做了一些工作,我找到了问题2的以下解释.

基本上,三角形可以由平面方程定义.这样你就可以写:

Ax + By + Cz = D.

然后你将z隔离得到z =(D - Ax - By)/ C.

然后你将这个公式除以z,就像你用透视除法一样,如果你开发,重新组合等,你得到:

1/z = C/D + A/D x/z + B/D y/z.

然后我们将C'= C/D B'= B/D命名为A'= A/D:

1/z = A'x/z + B'y/z + C'

它说x/z和y/z只是一旦投影在屏幕上三角形上的点的坐标,右边的等式是"仿射"函数,因此1/z是线性函数???

这对我来说似乎不是一个示范？或者这可能是正确的想法,但不能通过查看这是一个仿射函数的等式来说明你怎么说.如果你将所有条款相乘,你得到:

A'x + B'y + C'z = 1.

这基本上就是我们原来的方程式(只需用适当的术语代替A'B'和C').

我需要从一组点创建一个三角形网格。该集合的点数很少，因此不需要快速或优化（我最多处理 100 点）。网格需要是受约束的“delaunay 三角剖分”。在下图中，我（在左侧）显示了我开始的一组点（蓝色和红色点）。我也知道这些点之间的联系（黑色轮廓）。网格需要看起来像右侧的示例（包括形成外部和内部三角形的灰色边缘）。

我不能使用图书馆。

我研究了许多不同的算法。它们很多，很容易混淆。我想知道是否有一种简单且希望更简单的算法可以用来生成右侧的网格？蛮力方法很好（ps：我可以进行 Delaunay 三角剖分）。