小编use*_*526的帖子

我需要进行有限形式的光线追踪.我不需要反思.我只需要改变一个像素的颜色,这取决于它如何通过一个物体和折射.我也只需要测试光线和球体和磁盘之间的交叉点,没有别的.

这是我的着色器中的主要功能:

void main(void)
{
    Ray ray;
    ray.origin=vec3(0.5,0.5,.75);

    ray.direction=vec3(gl_FragCoord.x/width,gl_FragCoord.y/height,-gl_FragCoord.z)-ray.origin;
    ray.direction=normalize(ray.direction);

    gl_FragColor=trace(ray);
}

我的第一个问题是关于射线的起源.我如何获得它的位置？现在,我只是摆弄它直到看起来正确,但如果我改变屏幕的宽度或高度,我必须四处玩,直到它看起来正确.

我的第二个问题是关于光线和光盘之间的交叉.我这样做是首先检查光线是否与平面相交,然后检查交叉点是否在光盘的半径范围内.我的代码看起来像这样

float intersectPlane(Ray ray,vec3 point,vec3 normal)
{
    return dot(point-ray.origin,normal)/dot(ray.direction,normal);
}
...

det=intersectPlane(ray,bodies[count].position,vec3(0,0,1));
if(det>0)
{
        if(distance(det*ray.direction,bodies[count].position)<=bodies[count].radius) 
        {
            return vec4(1.0,0.0,0.0,1.0);
        }
}

问题是如果body [count] .radius小于或等于光线原点的z位置,则不显示任何内容.所以

if(det>0)
{
        if(distance(det*ray.direction,bodies[count].position)<=.76) 
        {
            return vec4(1.0,0.0,0.0,1.0);
        }
}

导致可见磁盘,而使用实际半径导致什么都没有.

我决定尝试给堆叠一次.我安装了它并用它来安装最新版本的ghc.我已经使用堆栈来安装一些软件包,但ghc看不到软件包,当我用ghc-pkg列出软件包时,我看到我通过堆栈安装的软件包不在那里.为什么是这样？我是否误解了堆栈的目的？

我只是尝试使用 FileReader 来显示图像文件，但是当我尝试使用 1 个以上的图像时，我得到以下“InvalidStateError：DOM Exception 11”。但是，在 Firefox 中，它运行良好。

这是我的代码

    function addImages(images)
            {
                var reader=new FileReader()

                reader.onload=function()
                {
                    $("#images").append('<img src="'+this.result+'"/><br/>')
                }

                for(var count=0;count<images.length;count++)
                {
                    reader.readAsDataURL(images[count])
                }
            }

            function uploadImagesToBrowser(e)
            {
                addImages(e.target.files)   
            }
$("#imagefiles").on("change",uploadImagesToBrowser)

显然,你可以使用decltype(foo())获取函数的返回类型,但是如果foo接受不起作用的参数,你必须将一些伪参数传递给foo才能使它工作.但是,有没有办法获得函数的返回类型而不必传递任何参数？

我一直在尝试使用openCL进行一些计算,但结果不正确.

我输入三个如下所示的float3:

[300000,0,0]
[300000,300000,0]
[300000,300000,300000]

进入这个内核:

__kernel void gravitate(__global const float3 *position,__global const float3 *momentum,__global const float3 *mass,__global float3 *newPosition,__global float3 *newMomentum,unsigned int numBodies,unsigned int seconds)
{
    int gid=get_global_id(0);

    newPosition[gid]=position[gid]*2;
    newMomentum[gid]=momentum[gid]*2;
}

我原本试图模拟一组物体的引力相互作用,这就是为什么内核看起来像那样.

对于输出我得到:

[600000.0,0.0,0.0]
[x,600000.0,0.0]
[600000.0,x,600000.0]

其中x是一个范围从NaN到0到10 ^ -44之间的值,并且每次运行内核时都不同.newPosition和newMomentum都具有相同的错误输出模式.

我正在使用的python代码如下所示:

def __init__(self):
        self.context=cl.create_some_context()
        self.queue=cl.CommandQueue(self.context)

        f=open("gravitate.cl")
        self.program=cl.Program(self.context,f.read()).build()

def simulate(self,seconds):
        bodyPosition=[]
        bodyMomentum=[]
        bodyMass=[]

        for body in self.objects:
            bodyPosition+=[body.position.x,body.position.y,body.position.z]
            bodyMomentum+=[body.momentum.x,body.momentum.y,body.momentum.z]
            bodyMass+=[body.mass]

        bodyPosition=numpy.array(bodyPosition).astype(numpy.float32)
        bodyMomentum=numpy.array(bodyMomentum).astype(numpy.float32)
        bodyMass=numpy.array(bodyMass).astype(numpy.float32)

        bodyPositionCl=cl.Buffer(self.context,cl.mem_flags.READ_ONLY|cl.mem_flags.COPY_HOST_PTR,hostbuf=bodyPosition)
        bodyMomentumCl=cl.Buffer(self.context,cl.mem_flags.READ_ONLY|cl.mem_flags.COPY_HOST_PTR,hostbuf=bodyMomentum)
        bodyMassCl=cl.Buffer(self.context,cl.mem_flags.READ_ONLY|cl.mem_flags.COPY_HOST_PTR,hostbuf=bodyMass)

        newBodyPosition=numpy.zeros(len(self.objects)*3).astype(numpy.float32)
        newBodyMomentum=numpy.zeros(len(self.objects)*3).astype(numpy.float32)

        newBodyPositionCl=cl.Buffer(self.context,cl.mem_flags.WRITE_ONLY,newBodyPosition.nbytes)
        newBodyMomentumCl=cl.Buffer(self.context,cl.mem_flags.WRITE_ONLY,newBodyMomentum.nbytes)

        self.program.gravitate(self.queue,(3,),None,bodyPositionCl,bodyMomentumCl,bodyMassCl,newBodyPositionCl,newBodyMomentumCl,numpy.uint32(len(self.objects)),numpy.uint32(seconds))
        cl.enqueue_read_buffer(self.queue,newBodyPositionCl,newBodyPosition).wait()
        cl.enqueue_read_buffer(self.queue,newBodyMomentumCl,newBodyMomentum).wait()

我有这个函数使用SSE2将一些值加在一起它应该将lhs和rhs加在一起并将结果存储回lhs:

template<typename T>
void simdAdd(T *lhs,T *rhs)
{
    asm volatile("movups %0,%%xmm0"::"m"(lhs));
    asm volatile("movups %0,%%xmm1"::"m"(rhs));

    switch(sizeof(T))
    {
        case sizeof(uint8_t):
        asm volatile("paddb %%xmm0,%%xmm1":);
        break;

        case sizeof(uint16_t):
        asm volatile("paddw %%xmm0,%%xmm1":);
        break;

        case sizeof(float):
        asm volatile("addps %%xmm0,%%xmm1":);
        break;

        case sizeof(double):
        asm volatile("addpd %%xmm0,%%xmm1":);
        break;

        default:
        std::cout<<"error"<<std::endl;
        break;
    }

    asm volatile("movups %%xmm0,%0":"=m"(lhs));
}

我的代码使用这样的函数:

float *values=new float[4];
float *values2=new float[4];

values[0]=1.0f;
values[1]=2.0f;
values[2]=3.0f;
values[3]=4.0f;

values2[0]=1.0f;
values2[1]=2.0f;
values2[2]=3.0f;
values2[3]=4.0f;

simdAdd(values,values2);
for(uint32_t count=0;count<4;count++) std::cout<<values[count]<<std::endl;

但是这不起作用,因为当代码运行时,输出1,2,3,4而不是2,4,6,8

我刚刚开始学习Haskell,为了实践,我决定创建一个函数,它接受一个树,它的元素有一个位置和大小,并返回位于某个位置的元素.我的代码看起来像这样:

import Data.List (dropWhile)

data Node = Node (Int,Int) (Int,Int) [Node] deriving(Eq, Show)

findNode :: (Int,Int) -> Node -> Maybe Node
findNode loc node@(Node (x, y) (width, height) []) = if loc >= (x, y) && loc <= (x+width, y+height) then Just node else Nothing
findNode loc node@(Node (x, y) (width, height) children) = 
    if loc >= (x, y) && loc <= (x+width, y+height)
        then if not $ null nodes then
            head nodes
        else
            Just node
    else Nothing
    where nodes …