blocks|key|1753211|text|第一种是易于实现和广泛使用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1753212|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The first is easy to implement and widely used.

blocks|key|3474122|text|在过去，我使用GL_SELECT来确定哪个对象贡献了感兴趣的像素，然后在需要时使用计算几何来获得与对象的精确交集。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3474123|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In the past I've used GL_SELECT to determine which object(s) contributed the pixel(s) of interest and then used computational geometry to get an accurate intersection with the object(s) if required.

blocks|key|1753275|text|你希望通过点击等高线(在边缘)或多边形内部来选择吗？第二种方法听起来像是你想要点击内部选择最紧的包含多边形。我不认为GL_SELECT在渲染GL_LINE_STRIP后将使内部响应点击。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1753276|如果这是一个真实的等高线图(我不认为它是，边缘似乎相交)，那么一个更简单的算法将是可用的。|1753277|entityMap^0|1M|9|1Y|D|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Do you expect to select by clicking the contour (on the edge) or the interior of the polygon? Your second approach sounds like you want clicks in the interior to select the tightest containing polygon. I don't think that <code>GL_SELECT</code> after rendering <code>GL_LINE_STRIP</code> is going to make the interior responsive to clicks.

If this was a true contour plot (from the image I don't think it is, edges appear to intersect) then a much simpler algorithm would be available.

blocks|key|3474146|text|我强烈反对+GL_SELECT。这种方法非常古老，在新的GL版本中也没有，您可能会遇到现代显卡的问题。不要期望硬件支持它--在许多GPU上可能会遇到这种模式的软件(驱动程序)退步，前提是它能工作。自费使用:)|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3474147|让我为你提供另一种选择。|3474148|对于实心的、大的物体，有一种古老而好的选择方法：|3474149|在光标position|3474150|drawing上启用剪刀测试并将其设置为1x1窗口的|unordered-list-item|3474151|没有灯光、纹理和多次采样，为每个“重要”实体指定了独特的实心颜色--这种颜色将成为picking|3474152|calling+glReadPixels的对象ID，并检索颜色，然后用于识别选中的object|3474153|clearing缓冲器，将剪刀重置到正常大小，并正常绘制场景。|3474154|3474155|3474156|这给了你一个非常可靠的“每个对象”的挑选方法。而且，只绘制和清除每像素操作最少的一个像素并不会真正损害您的性能，除非您缺少顶点处理能力(我认为是不太可能的)，或者有很多对象，并且很可能在绘制调用的次数上得到CPU绑定(但是，我再次相信，如果您可以按照每个像素数据传递颜色，那么就可以将其优化为一个抽签调用)。|3474157|RGB中的颜色是3个无符号字节，但是应该可以为最后一个字节额外使用框架缓冲区的alpha通道，因此总共可以得到4个字节--足够存储指向对象的任何32位指针作为颜色。|3474158|或者，您可以为此创建一个具有特定像素格式的专用框架缓冲区对象(比如GL_R32UI，如果需要64位，甚至创建GL_RG32UI+)。|CODE|3474159|以上是严格的几何方法的一个很好和快速的选择(在可靠性和实现时间方面)。|3474160|entityMap^0|5|A|0|0|0|0|0|0|0|0|0|0|0|0|X|8|1I|9|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1C|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1D|8|@]|D|@]|E|$]]|$1|O|3|P|5|N|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|R|5|N|7|1F|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|1G|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1J|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1K|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|1L|8|@$9|1M|A|1N|B|12]|$9|1O|A|1P|B|12]]|D|@]|E|$]]|$1|13|3|14|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|15|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|16|$]]

I strongly recommend against GL_SELECT. This method is very old and absent in new GL versions, and you're likely to get problems with modern graphics cards. Don't expect it to be supported by hardware - probably you'd encounter a software (driver) fallback for this mode on many GPUs, provided it would work at all. Use at your own risk :)

Let me provide you with an alternative.

For solid, big objects, there's an old, good approach of selection by:

<ul>
<li>enabling and setting the scissor test to a 1x1 window at the cursor position</li>
<li>drawing the screen with no lighting, texturing and multisampling, assigning an unique solid colour for every "important" entity - this colour will become the object ID for picking</li>
<li>calling glReadPixels and retrieving the colour, which would then serve to identify the picked object</li>
<li>clearing the buffers, resetting the scissor to the normal size and drawing the scene normally.</li>
</ul>

This gives you a very reliable "per-object" picking method. Also, drawing and clearing only 1 pixel with minimal per-pixel operation won't really hurt your performance, unless you are short on vertex processing power (unlikely, I think) or have really a lot of objects and are likely to get CPU-bound on the number of draw calls (but then again, I believe it's possible to optimize this away to a single draw call if you could pass the colour as per-pixel data).

The colour in RGB is 3 unsigned bytes, but it should be possible to additionally use the alpha channel of the framebuffer for the last byte, so you'd get 4 bytes in total - enough to store any 32-bit pointer to the object as the colour.

Alternatively, you can create a dedicated framebuffer object with a specific pixel format (like <code>GL_R32UI</code>, or even <code>GL_RG32UI</code> if you need 64 bits) for that.

The above is a nice and quick alternative (both in terms of reliability and in implementation time) for the strict geometric approach.

blocks|key|3474208|text|我发现在新的GPU上，GL_SELECT模式非常慢。我用了几种不同的方法来解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3474209|第一种方法是进行CPU碰撞测试，这是可行的，但没有我想要的那么快。当你将光线投射到屏幕上(使用gluUnproject)，然后试图找出鼠标与哪个物体相撞时，它的速度肯定会减慢。我获得满意速度的唯一方法是使用八叉树来减少碰撞测试的次数，然后进行边界盒碰撞测试--然而，这导致了一种像素不完美的方法。|3474210|我确定的方法是首先找到鼠标下的所有对象(使用gluUnproject和边界盒碰撞测试)，这通常非常快。然后，我将在后台缓冲区中可能与鼠标发生冲突的每个对象呈现为不同的颜色。然后，我使用glReadPixel获取鼠标下面的颜色，并将其映射回对象。glReadPixel是一个缓慢的调用，因为它必须从帧缓冲区读取。然而，它是每帧做一次，这最终花费了微不足道的时间。如果您愿意，可以通过呈现给PBO来加快速度。|3474211|贾瓦|3474212|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I found that on new GPUs, the GL_SELECT mode is extremely slow. I played with a few different ways of fixing the problem.

The first was to do a CPU collision test, which worked, but wasn't as fast as I would have liked. It definitely slows down when you are casting rays into the screen (using gluUnproject) and then trying to find which object the mouse is colliding with. The only way I got satisfactory speeds was to use an octree to reduce the number of collision tests down and then do a bounding box collision test - however, this resulted in a method that was not pixel perfect.

The method I settled on was to first find all the objects under the mouse (using gluUnproject and bounding box collision tests) which is usually very fast. I then rendered each of the objects that have potentially collided with the mouse in the backbuffer as a different color. I then used glReadPixel to get the color under the mouse, and map that back to the object. glReadPixel is a slow call, since it has to read from the frame buffer. However, it is done once per frame, which ends up taking a negligible amount of time. You can speed it up by rendering to a PBO if you'd like.

Giawa

blocks|key|1753386|text|如果你和线在一起，你就不能使用select，因为你必须点击渲染的线条像素，而不是线条中的空格，我把它们作为你想要做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1753387|您可以使用Kos的答案，但为了渲染您需要的空间，实心填充它，这将涉及到将您的所有轮廓转换为凸类型，这是痛苦的。因此，我认为这有时会奏效，并且在某些情况下给出错误的答案，除非你这样做。|1753388|您需要做的是使用CPU。您可以从视图端口和透视矩阵获得视图范围。使用鼠标坐标，生成指向鼠标指针向量的视图。你也有所有的等高线和弦。|1753389|获取第一个等高线的第一个坐标，并向第二个等高线生成向量。用它们做一个矢量。取第三个坐标，从2到3生成一个向量，在你的轮廓周围重复，最后再把最后一个从coord返回到0。对每一对按顺序排列，找出交叉乘积，并总结所有结果。当你有最后的求和向量时，保持它，用鼠标指针方向向量做一个点积。如果它的%2Bve那么鼠标在等高线内，如果它的-ve那么它不是，如果0，那么我猜这个等高线的平面和鼠标方向是平行的。|1753390|对每个等高线都这样做，然后你就会知道其中哪一个是被你的鼠标刺进的。这取决于你想从那一套中挑选哪一个。最高Z？|1753391|这听起来像是很多工作，但也不算太糟，而且会给出正确的答案。您可能还想要保持所有轮廓的包围框，然后您可以通过对整个向量做相同的数学运算，从而提前从鼠标向量中提取出来，但是只在4面，如果不在里面，则轮廓不能是任何一种。|1753392|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

You cant use select if you stay with the lines because you would have to click on the line pixels rendered not the space inside the lines bounding them which I read as what you wish to do.

You can use Kos's answer but in order to render the space you need to solid fill it which would involve converting all of your contours to convex types which is painful. So I think that would work sometimes and give the wrong answer in some cases unless you did that.

What you need to do is use the CPU. You have the view extents from the viewport and the perspective matrix. With the mouse coord, generate the view to mouse pointer vector. You also have all the coords of the contours.

Take the first coord of the first contour and make a vector to the second coord. Make a vector out of them. Take 3rd coord and make a vector from 2 to 3 and repeat all the way around your contour and finally make the last one from coord n back to 0 again. For each pair in sequence find the cross product and sum up all the results. When you have that final summation vector keep hold of that and do a dot product with the mouse pointer direction vector. If its +ve then the mouse is inside the contour, if its -ve then its not and if 0 then I guess the plane of the contour and the mouse direction are parallel.

Do that for each contour and then you will know which of them are spiked by your mouse. Its up to you which one you want to pick from that set. Highest Z ?

It sounds like a lot of work but its not too bad and will give the right answer. You might like to additionally keep bounding boxes of all your contours then you can early out the ones off of the mouse vector by doing the same math as for the full vector but only on the 4 sides and if its not inside then the contour cannot be either.

blocks|key|1753420|text|umanga，Cant看如何在网上回复..。也许我应该注册:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1753421|首先，我必须向你道歉，因为我给了你错误的algo+--我选了一张脸。但你所需要的是非常相似的，这就是为什么我感到困惑.哦哦。|1753422|像前面说的那样，把相机定位到鼠标矢量。|1753423|对于每个等高线，以成对的方式遍历所有的同弦(0-1，1-2，2-3，.和以前一样用它做一个vec。即沿等高线走。|1753424|现在做这两个的交叉刺激(等高线边缘到鼠标vec)，而不是像我前面说的那样在对之间做，对所有的对和向量都加起来。|1753425|最后，找出得到的向量的大小。如果结果是零(考虑四舍五入的错误)，那么你的外部形状-不管面对什么。如果你对面对感兴趣，那么你可以用鼠标向量做点戳，找出面向，然后测试符号%2B/-。|1753426|它可以工作，因为algo可以依次找到从向量线到每个点的距离。当你把它们加起来，你就在外面，它们都会抵消掉，因为等高线是封闭的。如果你的内心，那么他们都总结。它实际上是物理学中的高斯电磁场定律。|1753427|参见：http://en.wikipedia.org/wiki/Gauss%2527s_law和注意：“方程的右边是用电常数除以S的总电荷”，注意“封闭”一词--即零的意思不是封闭的。|offset|length|1753428|您仍然可以使用限界框进行优化以提高速度。|1753429|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Gauss%2527s/_law^0|0|0|0|0|0|0|0|3|16|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@$P|19|Q|1A|1|1B]]|A|$]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

umanga, Cant see how to reply inline... maybe I should sign up :)

First of all I must apologize for giving you the wrong algo - i did the back face culling one. But the one you need is very similar which is why I got confused... d'oh.

Get the camera position to mouse vector as said before.

For each contour, loop through all the coords in pairs (0-1, 1-2, 2-3, ... n-0) in it and make a vec out of them as before. I.e. walk the contour.

Now do the cross prod of those two (contour edge to mouse vec) instead of between pairs like I said before, do that for all the pairs and vector add them all up.

At the end find the magnitude of the resulting vector. If the result is zero (taking into account rounding errors) then your outside the shape - regardless of facing. If your interested in facing then instead of the mag you can do that dot prod with the mouse vector to find the facing and test the sign +/-.

It works because the algo finds the amount of distance from the vector line to each point in turn. As you sum them up and you are outside then they all cancel out because the contour is closed. If your inside then they all sum up. Its actually Gauss's Law of electromagnetic fields in physics...

See:http://en.wikipedia.org/wiki/Gauss%27s_law and note "the right-hand side of the equation is the total charge enclosed by S divided by the electric constant" noting the word "enclosed" - i.e. zero means not enclosed.

You can still do that optimization with the bounding boxes for speed.

As seen in the image 

<img src="https://i.stack.imgur.com/mhHwD.png" alt="http://oi56.tinypic.com/ifu33k.jpg">

I draw set of contours (polygons) as GL_LINE_STRIP.
Now I want to select curve(polygon) under the mouse to delete,move..etc in 3D .

I am wondering which method to use:

1.use OpenGL picking and selection. ( glRenderMode(GL_SELECT) )

2.use manual collision detection , by using a pick-ray and check whether the ray is inside each polygon.

OpenGL GL_SELECT or manual collision detection?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如图所示​​我画一组等高线(多边形)为GL_LINE_STRIP。现在我想选择曲线(多边形)下的鼠标删除，move..etc在3D。我想知道使用哪种方法：1.采用OpenGL采摘和选择。( glRenderMode(GL_SELECT) )2.使用手动碰撞检测，使用拾取射线，并检查光线是否在每个多边形内。

问OpenGL GL_SELECT还是手动碰撞检测？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问OpenGL GL_SELECT还是手动碰撞检测？EN