コード例 #1
0
ファイル: CPU_VD.cpp プロジェクト: hksonngan/invols
	ivec3 GetRecomendedGPUOffset()
	{
		ivec3 pos(CT::GetCenter().x*CPU_VD::full_data.GetSize().x, CT::GetCenter().y*CPU_VD::full_data.GetSize().y, CT::GetCenter().z*CPU_VD::full_data.GetSize().z);
		pos -= gpu_size_dummy/2;
		pos -= ivec3::Max(gpu_size_dummy+pos-CPU_VD::full_data.GetSize(),ivec3(0));
		pos = ivec3::Max(ivec3(0),pos);
		return pos;
	}
コード例 #2
0
ファイル: ClipmapRing.cpp プロジェクト: yixinxie/TestDC
void ClipmapRing::reposition(const ivec3& _pos, const ivec3& _innerPos){
	
	ivec3 origin = ring[calcRingIndex(start.x,start.y, start.z)].pos;
	ivec3 diff = _pos - origin;
	// we expect the values in diff should be either zero, or unitSize
	ivec3 normalizedDiff = diff / unitSize;
	start += normalizedDiff;
	ivec3 start = ivec3_mod(start, RING_DIM);

	//int z = 0; {
	for (int z = 0; z < RING_DIM; z++){
		for (int y = 0; y < RING_DIM; y++){
			for (int x = 0; x < RING_DIM; x++){

				ivec3 thisPos = _pos + ivec3(x, y, z) * unitSize;
				// find the corresponding node.
				ivec3 nxyz = ivec3_mod(ivec3(x + start.x, y + start.y, z + start.z), RING_DIM);
				int idx = calcRingIndex(nxyz.x, nxyz.y, nxyz.z);
				ivec3 posFromNode = ring[idx].pos;
				bool inRing;
				if (noInner)inRing = belongsToNoInner(thisPos, _pos);
				else inRing = belongsTo(thisPos, _pos, _innerPos);
				if (inRing){
					if (ring[idx].activated == 1){
						if (posFromNode == thisPos){
							// keep
							printf_s("keep %d, %d, %d\n", thisPos.x, thisPos.y, thisPos.z);
						}
						else{
							// remove and regenerate
							printf_s("remove %d, %d, %d === generate %d, %d, %d\n", posFromNode.x, posFromNode.y, posFromNode.z, thisPos.x, thisPos.y, thisPos.z);
							ring[idx].pos = thisPos;
							vcManager->relocateChunk(&ring[idx], thisPos);
						}
					}
					else{
						// first allocation
						printf_s("claim %d, %d, %d\n", thisPos.x, thisPos.y, thisPos.z);
						ring[idx].activated = 1;
						ring[idx].pos = thisPos;
						vcManager->createChunk(thisPos, lod, &ring[idx]);
					}
				}
				else{
					if (ring[idx].activated == 1){
						printf_s("release %d, %d, %d\n", thisPos.x, thisPos.y, thisPos.z);
						ring[idx].activated = 0;
						vcManager->removeChunk(&ring[idx]);
					}
				}
			}
		}
	}
}
コード例 #3
0
ファイル: cursorscantool.cpp プロジェクト: ericandoh/Bawk
void CursorScanTool::step(int ms) {
    if (current_stage == ScanStages::SETTING_LOWER ||
        current_stage == ScanStages::SETTING_UPPER ||
        current_stage == ScanStages::EXTENDING) {
        if (BlockTracing::show_item) {
            show_item = true;
            
            Entity* at = BlockTracing::selected;
            if (at->entity_class == EntityType::BASEWORLD ||
                at->entity_class == EntityType::SUPEROBJECT ||
                at->entity_class == EntityType::GAMETEMPLATE) {
                target = (SuperObject*)at;
            }
            else {
                target = at->parent;
            }
            
            if (current_stage == ScanStages::SETTING_LOWER) {
                lower = BlockTracing::pointed_rounded_pos;
                box.lower = lower;
                box.upper = ivec3(lower.x + 1,
                                  lower.y + 1,
                                  lower.z + 1);
            }
            else if (current_stage == ScanStages::SETTING_UPPER) {
                upper = BlockTracing::pointed_rounded_pos;
                box.lower = lower;
                box.upper = upper;
                box.refit();
                box.upper += 1;
            }
            else if (current_stage == ScanStages::EXTENDING) {
                // TODO calculate extending box
                extended = BlockTracing::pointed_rounded_pos;
                extending_box.lower = lower;
                extending_box.upper = upper;
                extending_box.refit();
                extending_box.expand(extended);
                extending_box.upper += 1;
            }
            player_orientation = get_player_direction();
        }
        else {
            show_item = false;
            if (current_stage == ScanStages::SETTING_UPPER) {
                box.upper = ivec3(lower.x + 1,
                                  lower.y + 1,
                                  lower.z + 1);
            }
        }
    }
}
コード例 #4
0
ファイル: player.cpp プロジェクト: ericandoh/Bawk
ivec3 Player::get_rounded_forward() {
    fvec3 dir = angle.get_dir();
    if (fabsf(dir.x) > fabsf(dir.z)) {
        if (dir.x < 0) {
            return ivec3(-1, 0, 0);
        }
        return ivec3(1, 0, 0);
    }
    else {
        if (dir.z < 0) {
            return ivec3(0, 0, -1);
        }
        return ivec3(0, 0, 1);
    }
}
コード例 #5
0
ファイル: View2D.cpp プロジェクト: hksonngan/invols
void View2D::UpdateSumMip()
{
	if(!CPU_VD::full_data.GetSlices())return;
	Progress progress(wxT("Generating 2D MIP,SUM..."));
	Progress::inst->AddText(wxT("init"));
	ivec3 size = CPU_VD::full_data.GetSize();

	int ww = size.GetByID(axis_x),hh = size.GetByID(axis_y),dd = size.GetByID(axis);
	short* data;
	sum.Allocate(ivec3(ww,hh,1),CPU_VD::full_data.GetValueFormat());
	mip.Allocate(ivec3(ww,hh,1),CPU_VD::full_data.GetValueFormat());
	int* sum1 = new int[ww*hh];
	for(int i=0;i<ww*hh;i++)
	{
		sum1[i]=0;
	}
	mip.SetAllValues(0);
	ivec3 bb1 = ivec3(0);//CT::GetBoundingBox(0);
	ivec3 bb2 = CPU_VD::full_data.GetSize()-ivec3(1);//CT::GetBoundingBox(1);
	ivec3 id;
	//short min_val = short(bc.x*256*128);
	//short max_val = short(bc.y*256*128);
	int*idx=&id.x+axis_x;
	int*idy=&id.x+axis_y;
	for(id.z=bb1.z;id.z<=bb2.z;id.z++)
	{
	for(id.y=bb1.y;id.y<=bb2.y;id.y++)
	for(id.x=bb1.x;id.x<=bb2.x;id.x++)
	{
		short val = CPU_VD::full_data.GetValue(id);
		//if(val>=min_val && val<=max_val)
		{
			int idd = *idx+ww**idy;
			sum1[idd] += val;
			short tmp=mip.GetValue(*idx,*idy,0);
			if(tmp<val)mip.SetValue(val,*idx,*idy,0);
		}
		
	}
	Progress::inst->SetPercent((id.z-bb1.z)/(float)(bb2.z-bb1.z));
	}
	dd/=2;
	for(int i=0;i<ww*hh;i++)
	{
		sum.SetValue(sum1[i]/dd,i%ww,i/ww,0);
	}
	delete[]sum1;
}
コード例 #6
0
ファイル: CPU_VD.cpp プロジェクト: hksonngan/invols
namespace CPU_VD
{
	VData full_data;
	
	ivec3 gpu_size=ivec3(0);
	ivec3 gpu_size_dummy=ivec3(512);
	ivec3 gpu_offset=ivec3(0);
	
	float scale=1;

	vec3 real_gpu_b1(0),real_gpu_b2(0);

	vec3 GetScale()
	{
		return (full_data.spacing*full_data.GetSize().ToVec3())*scale;
	}
	vec3 GetFullSize()
	{
		return (full_data.spacing*full_data.GetSize().ToVec3())*scale;
	}

	void CalcReal()
	{
		CPU_VD::real_gpu_b1 = ((CPU_VD::gpu_offset.ToVec3())/CPU_VD::full_data.GetSize().ToVec3())*CPU_VD::GetScale();
		CPU_VD::real_gpu_b2 = (((CPU_VD::gpu_offset+CPU_VD::gpu_size).ToVec3())/CPU_VD::full_data.GetSize().ToVec3())*CPU_VD::GetScale();
		CT::need_rerender=1;
		CT::need_rerender2d=1;
	}
	void UnInit()
	{
		full_data.Clear();
	}
	
	ivec3 GetRecomendedGPUOffset()
	{
		ivec3 pos(CT::GetCenter().x*CPU_VD::full_data.GetSize().x, CT::GetCenter().y*CPU_VD::full_data.GetSize().y, CT::GetCenter().z*CPU_VD::full_data.GetSize().z);
		pos -= gpu_size_dummy/2;
		pos -= ivec3::Max(gpu_size_dummy+pos-CPU_VD::full_data.GetSize(),ivec3(0));
		pos = ivec3::Max(ivec3(0),pos);
		return pos;
	}
	
	ivec3 GetIPos(vec3 pos)
	{
		return (pos*CPU_VD::full_data.GetSize().ToVec3()).ToIVec3();
	}

}
コード例 #7
0
ファイル: synth2dreader.cpp プロジェクト: molsimmsu/3mview
VolumeList* Synth2DReader::read(const std::string &fileName) throw (tgt::FileException, std::bad_alloc) {
    RawVolumeReader rawReader(getProgressBar());

    FILE* fin = fopen(fileName.c_str(), "rb");
    char buf[4096];
    fread(buf, 4096, 1, fin);
    fclose(fin);

    Synth2DVolumeHeader* header = (Synth2DVolumeHeader *)buf;
    if ((header->magic[0] != 'V') || (header->magic[1] != 'O') || (header->magic[2] != 'L') || (header->magic[3] != 'U') || (header->version != 4)
            || (header->bytesPerChannel != 1) || (header->numChannels != 1 && header->numChannels != 3 && header->numChannels != 4))
        throw tgt::CorruptedFileException("error while reading data", fileName);

    std::string om("I");
    if(header->numChannels == 3)
        om = std::string("RGB");
    else if(header->numChannels == 4)
        om = std::string("RGBA");

    ivec3 dims(header->volSize);
    rawReader.setReadHints(dims,                     // dimensions of the volume
                           ivec3(1, 1, 1),           // thickness of one slice
                           om,                       // intensity, rgb or rgba image
                           "UCHAR",                  // one unsigned char per voxel
                           1,                        // number of time frames
                           4096);                    // header skip

    VolumeList* volumeList = rawReader.read(fileName);

    return volumeList;
}
コード例 #8
0
ファイル: voxeditor.cpp プロジェクト: Dakror/voxie
ivec3 VoxelEditor::get_pos_vec(const vec3 & v)
{
    int x = int(v.x - voxel->x_offset);
    int y = int(v.y - voxel->y_offset);
    int z = int(v.z - voxel->z_offset);
    return ivec3(x, y, z);
}
コード例 #9
0
MarchingCubesRenderer::MarchingCubesRenderer()
{
  _id = ObjectIDGenerator::getInstance().getNextID();
  MeshBufferInfo* mbi = new MeshBufferInfo(GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW, GL_TRIANGLES);
  _mesh = new Mesh(mbi);
  _meshGS = new Mesh();
  viewOrient = vec3(1, 0, 1.5);

  cubeSize = vec3(48, 48, 48);
  cubeStep = vec3(2.0f, 2.0f, 2.0f) / cubeSize;

  dataSize = ivec3(128, 128, 128);

  isolevel = 40.5f;
  animate = true;
  autoWay = true;
  curData = 0;
  mode = 1;
  enableSwizzledWalk = false;

  wireframe = false;
  gridData = nullptr;

  _renderSortValue = IRenderable::DefaultSortValue;
}
コード例 #10
0
ファイル: PN_Triangle.cpp プロジェクト: hksonngan/astrocytes
void MakeSmoothed(Geometry*src_g,Geometry*dst_g,int order)
{
	if(order<2)return;
	vec3 nrm[3];
	for(int i=0;i<src_g->face.size();i++)
	{
		for(int ii=0;ii<3;ii++)
		{
			nrm[ii] = src_g->norm[src_g->face[i].GetByID(ii)];
			//if(vec3::dot(nrm[ii] , src_g->tr[i].norm)<0.5)				nrm[ii] = src_g->tr[i].norm;	
		}
		PN_Triangle pnt(src_g->vert[src_g->face[i].x],src_g->vert[src_g->face[i].y],src_g->vert[src_g->face[i].z],
						src_g->norm[src_g->face[i].x],src_g->norm[src_g->face[i].y],src_g->norm[src_g->face[i].z],
						nrm[0],nrm[1],nrm[2],
						src_g->vert_col[src_g->face[i].x],src_g->vert_col[src_g->face[i].y],src_g->vert_col[src_g->face[i].z]);
		int v_offset = dst_g->vert.size();

		for(int u=0;u<order;u++)
			for(int v=0;v<order-u;v++)
			{
				float fu = u/float(order-1);
				float fv = v/float(order-1);
				dst_g->vert.push_back(pnt.GetVertex(fu,fv));
				dst_g->norm.push_back(pnt.GetNormal(fu,fv));
				dst_g->vert_col.push_back(pnt.GetColor(fu,fv));
			}
		int off0=0,off1=0;
		for(int u=0;u<order-1;u++)
		{
			for(int v=0;v<order-u-1;v++)
			{
				int v00 = v_offset + u*order+v-off0;
				int v01 = v_offset + (u+1)*order+v-off1;
				int v10 = v_offset + (u)*order+v+1-off0;
				int v11 = v_offset + (u+1)*order+v+1-off1;
				
				dst_g->face.push_back(ivec3(v00,v01,v10));
				if(v!=order-u-2)
					dst_g->face.push_back(ivec3(v01,v11,v10));
			}
			if(u>=0)off1+=u+1;
			if(u>=1)off0+=u;
		}
	}

}
コード例 #11
0
ファイル: volumemaxclprocessor.cpp プロジェクト: sunwj/inviwo
VolumeMaxCLProcessor::VolumeMaxCLProcessor()
    : Processor()
    , ProcessorKernelOwner(this)
    , inport_("volume")
    , outport_("volume")
    , volumeRegionSize_("region", "Region size", 8, 1, 100)
    , workGroupSize_("wgsize", "Work group size", ivec3(8), ivec3(0), ivec3(256))
    , useGLSharing_("glsharing", "Use OpenGL sharing", true)
    , supportsVolumeWrite_(false)
    , tmpVolume_(nullptr)
    , kernel_(nullptr) {
    addPort(inport_);
    addPort(outport_);

    addProperty(volumeRegionSize_);
    addProperty(workGroupSize_);
    addProperty(useGLSharing_);
}
コード例 #12
0
ファイル: ClipmapRing.cpp プロジェクト: yixinxie/TestDC
void ClipmapRing::createEdgeDescs(ClipmapRing* innerRing, ClipmapRing* outterRing){
	const ivec3 adjacencyInfo[6] = {
		ivec3(-unitSize, 0, 0), ivec3(0, -unitSize, 0), ivec3(0, 0, -unitSize),
		ivec3(0, -unitSize, -unitSize), ivec3(-unitSize, 0, -unitSize), ivec3(-unitSize, -unitSize, 0)
	};
	for (int z = 0; z < RING_DIM; z++){
		for (int y = 0; y < RING_DIM; y++){
			for (int x = 0; x < RING_DIM; x++){
				bool inRing;
				ivec3 thisPos = originPos + ivec3(x, y, z) * unitSize;
				if (noInner)inRing = belongsToNoInner(thisPos, originPos);
				else inRing = belongsTo(thisPos, originPos, innerCubePos);
				if (inRing){
					ivec3 nxyz = ivec3_mod(ivec3(x + start.x, y + start.y, z + start.z), RING_DIM);
					int idx = calcRingIndex(nxyz.x, nxyz.y, nxyz.z);
					VoxelChunk* curChunk = ring[idx].chunk;
					for (int i = 0; i < 6; i++){
						ivec3 adjPos = ring[idx].pos + adjacencyInfo[i];
						int adjType = adjacencyTypes(adjPos);
						if (i < 3){
							if (adjType == 0){
								// a normal 1 to 1 relationship.
								const VCNode* adjNode = getNodeByCoord(adjPos);
								curChunk->createEdgeDesc2D(adjType, 0, 0, adjNode->chunk, i);
							}
							else if(adjType == 1){
								// now there are 4 chunks that are adjacent to curChunk.
								// they lie in the ring inside this clipmap ring.
								VCNode node0, node1, node2, node3;
								innerRing->getNodesFromInner(adjPos, i, &node0, &node1, &node2, &node3);
								curChunk->createEdgeDesc2D(adjType, 0, 0, node0.chunk, i);
								curChunk->createEdgeDesc2D(adjType, 1, 0, node1.chunk, i);
								curChunk->createEdgeDesc2D(adjType, 0, 1, node2.chunk, i);
								curChunk->createEdgeDesc2D(adjType, 1, 1, node3.chunk, i);
							}
							else if (adjType == -1){
								// the adjacent chunk is larger than curChunk.
								// curChunk only has enough data to describe 1 / 4 of its edge desc.
								ivec3 local = ivec3_mod(adjPos, unitSize);
								ivec3 tempAdjPos = adjPos - local;
								const VCNode* adjNode = outterRing->getNodeByCoord(tempAdjPos);
								if ( i == 0)
									curChunk->createEdgeDesc2D(adjType, local.z, local.y, adjNode->chunk, i);
							}
						}
						else{

						}
					}
				}
			}
		}
	}
}
コード例 #13
0
Deform_With_Seg::Deform_With_Seg(void)
{
	near_point = 20;
	scale_factor = 1.5;
	color_list.clear();
	for (int i = 0; i < 10; i++)
	{
		color_list.push_back(ivec3((int)(255 * (float)(rand()) / RAND_MAX), (int)(255 * (float)(rand()) / RAND_MAX), (int)(255 * (float)(rand()) / RAND_MAX)));
	}
}
コード例 #14
0
ファイル: View2D.cpp プロジェクト: hksonngan/invols
void View2D::LoadTexture()
{

	if(!CPU_VD::full_data.GetSlices())return;
	need_texture_reload=0;
	ivec3 size = CPU_VD::full_data.GetSize();
	if(cur_slice<0 || cur_slice>=size.GetByID(axis))return;
	if(txt2)delete txt2;
	int ww = size.GetByID(axis_x),hh = size.GetByID(axis_y);
	
	VData data(ivec3(ww,hh,1),CPU_VD::full_data.GetValueFormat());
	void *dt;
	
	if(to_show==0)
	{
	if(axis==2)
		dt = CPU_VD::full_data.GetSlice(cur_slice);
	else
	{
		dt = data.GetSlice(0);
		
		if(axis==0)
		{//ww-y//hh-z
			for(int j=0;j<hh;j++)
			for(int i=0;i<ww;i++)
			{
				//data[i+ww*j] = *(CPU_VD::full_data.g + cur_slice + size.x*(i+j*size.y));
				data.SetValue(CPU_VD::full_data.GetValue(cur_slice,i,j), i,j,0);
			}
		}else
			for(int j=0;j<size.z;j++)
			for(int i=0;i<size.x;i++)
			{
				//data[i+ww*j] = *(CPU_VD::full_data + i + size.x*(cur_slice+j*size.y));
				data.SetValue(CPU_VD::full_data.GetValue(i,cur_slice,j), i,j,0);
			}
	}
	}else
	if(to_show==1)
	{
		if(!sum.GetSlices())UpdateSumMip();
		dt = sum.GetSlice(0);
	}else
	if(to_show==2)
	{
		if(!mip.GetSlices())UpdateSumMip();
		dt = mip.GetSlice(0);
	}

	txt2 = new SimText3D(2,ww,hh,1,1,dt,0,1,data.GetGLFormat());

	data.Clear();
}
コード例 #15
0
ファイル: ClipmapRing.cpp プロジェクト: yixinxie/TestDC
void ClipmapRing::initPos(ivec3 _pos, int _lod){
	lod = _lod;
	unitSize = 1 << lod;
	noInner = true;
	for (int z = 0; z < RING_DIM; z++){
		for (int y = 0; y < RING_DIM; y++){
			for (int x = 0; x < RING_DIM; x++){
				int idx = calcRingIndex(x, y, z);
				ivec3 thisPos = _pos + ivec3(x, y, z) * unitSize;
				ring[idx].pos = thisPos;
				if (belongsToNoInner(thisPos, _pos)){
					ring[idx].activated = 1;
					vcManager->createChunk(ring[idx].pos, lod, &ring[idx]);
				}

			}
		}
	}
	originPos = _pos;
	start = ivec3(0, 0, 0);
}
コード例 #16
0
ファイル: Renderer6.cpp プロジェクト: salpeev/LearnGL2
void Renderer6::GenerateSkinData()
{
    m_skinCylinder = new Cylinder(1.0f, 0.25f);
    
    int bonesCount = m_chain->GetBones()->size();
    int offset = 0;
    for (int i = 0; i < bonesCount; i++)
    {
        vector<float> vertices;
        vector<GLushort> indices;
        
        if (i == 0) {
            m_skinCylinder->GenerateVertices(vertices, VertexFlagsBoneWeights, ivec3(0, 0, 1));
        } else if (i == bonesCount - 1) {
            m_skinCylinder->GenerateVertices(vertices, VertexFlagsBoneWeights, ivec3(i - 1, i, i));
        } else {
            m_skinCylinder->GenerateVertices(vertices, VertexFlagsBoneWeights, ivec3(i - 1, i, i + 1));
        }
        
        m_skinCylinder->GenerateLineIndices(indices);
        
        for (int j = 0; j < vertices.size(); j++) {
            m_skinVertices.push_back(vertices[j]);
        }
        
        for (int j = 0; j < indices.size(); j++) {
            m_skinIndices.push_back(indices[j] + offset);
        }
        
        offset += m_skinCylinder->GetVertexCount();
    }
    
    glGenBuffers(1, &m_skinVertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_skinVertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * m_skinVertices.size(), &m_skinVertices[0], GL_STATIC_DRAW);
    
    glGenBuffers(1, &m_skinIndexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_skinIndexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * m_skinIndices.size(), &m_skinIndices[0], GL_STATIC_DRAW);
}
コード例 #17
0
CL::Event Reyes::RendererCL::send_batch(Reyes::Batch& batch,
                                        const mat4& matrix, const mat4& proj, const vec4& color, PatchType patch_type,
                                        const CL::Event& ready)
{
    
    // We can't handle more patches on the fly atm
    int patch_count = std::min<int>(reyes_config.reyes_patches_per_pass(), batch.patch_count);
    
    if (patch_count == 0) {
        return _last_batch;
    }

    CL::Event e;
    
    const int patch_size  = reyes_config.reyes_patch_size();
    const int group_width = reyes_config.dice_group_width();

    // DICE
    switch (patch_type) {
    case BEZIER:
        _dice_bezier_kernel->set_args(batch.patch_buffer, batch.patch_ids, batch.patch_min, batch.patch_max,
                                      _pos_grid, _pxlpos_grid, _depth_grid,
                                      matrix, proj);
        
        e = _rasterization_queue.enq_kernel(*_dice_bezier_kernel,
                                            ivec3(patch_size + group_width, patch_size + group_width, patch_count),
                                            ivec3(group_width, group_width, 1),
                                            "dice", ready);
        break;
    case GREGORY:
        _dice_gregory_kernel->set_args(batch.patch_buffer, batch.patch_ids, batch.patch_min, batch.patch_max,
                                      _pos_grid, _pxlpos_grid, _depth_grid,
                                      matrix, proj);
        
        e = _rasterization_queue.enq_kernel(*_dice_gregory_kernel,
                                            ivec3(patch_size + group_width, patch_size + group_width, patch_count),
                                            ivec3(group_width, group_width, 1),
                                            "dice", ready);
        break;
    }
    
    
    // SHADE
    _shade_kernel->set_args(_pos_grid, _pxlpos_grid, _block_index, _color_grid, color);
    e = _rasterization_queue.enq_kernel(*_shade_kernel, ivec3(patch_size, patch_size, patch_count),  ivec3(8,8,1),
                                        "shade", e);

    // SAMPLE
    _sample_kernel->set_args(_block_index, _pxlpos_grid, _color_grid, _depth_grid,
                             _tile_locks, _framebuffer.get_buffer(), _depth_buffer);
    e = _rasterization_queue.enq_kernel(*_sample_kernel, ivec3(8,8,patch_count * square(patch_size/8)), ivec3(8,8,1),
                                        "sample", _framebuffer_cleared | e);
    _framebuffer_cleared = CL::Event();

    _rasterization_queue.flush();

    return e;
}
コード例 #18
0
ファイル: chunkrender.cpp プロジェクト: ericandoh/Bawk
void RenderableChunk::update_dimensions() {
    // TOFU could this be slightly more efficient? a loop over 4k elements isnt the most efficient...
    // small, large: inclusive-inclusive
    lower_bound = ivec3(CX, CY, CZ);
    upper_bound = ivec3(0, 0, 0);
    if (block_counter == 0)
        return;
    block_counter = 0;
    for (int x = 0; x < CX; x++) {
        for (int y = 0; y < CY; y++) {
            for (int z = 0; z < CZ; z++) {
                if (blk[x][y][z].type) {
                    block_counter++;
                    lower_bound.x = imin(x, lower_bound.x);
                    lower_bound.y = imin(y, lower_bound.y);
                    lower_bound.z = imin(z, lower_bound.z);
                    upper_bound.x = imax(x, upper_bound.x);
                    upper_bound.y = imax(y, upper_bound.y);
                    upper_bound.z = imax(z, upper_bound.z);
                }
            }
        }
    }
}
コード例 #19
0
ファイル: freetype-gl.cpp プロジェクト: andrew-pa/gluk
    // ---------------------------------------------------- texture_atlas_clear ---
    void
    texture_atlas_clear( texture_atlas_t * self )
    {
        ivec3 node = ivec3(1,1,1);

        assert( self );
        assert( self->data );

        vector_clear( self->nodes );
        self->used = 0;
        // We want a one pixel border around the whole atlas to avoid any artefact when
        // sampling texture
        node.z = self->width-2;

        vector_push_back( self->nodes, &node );
        memset( self->data, 0, self->width*self->height*self->depth );
    }
コード例 #20
0
ファイル: cursorscantool.cpp プロジェクト: ericandoh/Bawk
bool CursorScanTool::confirmed() {
    if (current_stage == ScanStages::SELECTED) {
        // copies the area selected into the first cursorobject that is available
        // TODO copy entities as well
        CursorItemInfo* info = new CursorItemInfo((uint32_t)get_player()->getID(),
                                                  (uint32_t)get_player()->assignID(),
                                                  CursorType::CURSOR_SUPEROBJECT);
        CursorSuperObject* object = new CursorSuperObject(info);// all templates are made on the bar
        // TODO giraffes (center chunk and set position to box.lower + box.upper)
        object->set_pos(box.lower);
        for (int x = box.lower.x; x < box.upper.x; x++) {
            for (int y = box.lower.y; y < box.upper.y; y++) {
                for (int z = box.lower.z; z < box.upper.z; z++) {
                    block_type* blk = target->get_block_integral(x, y, z);
                    object->set_block_integral(x, y, z, *blk);
                }
            }
        }
        // TOFU what if inventory is open and this gets executed...?
        get_player()->inventory->add_custom(info);
        get_item_bar()->set_first_available(object);
        current_stage = ScanStages::SETTING_LOWER;
    }
    else if (current_stage == ScanStages::EXTENDED) {
        // fills in the extra blocks using the original as a template, over a repeating pattern
        // TODO copy over models in the area as well with equal frequency
        for (int x = extending_box.lower.x; x < extending_box.upper.x; x++) {
            for (int y = extending_box.lower.y; y < extending_box.upper.y; y++) {
                for (int z = extending_box.lower.z; z < extending_box.upper.z; z++) {
                    if (box.hits(ivec3(x,y,z)))
                        continue;
                    int xm = get_positive_mod((x - box.lower.x), (box.upper.x - box.lower.x)) + box.lower.x;
                    int ym = get_positive_mod((y - box.lower.y), (box.upper.y - box.lower.y)) + box.lower.y;
                    int zm = get_positive_mod((z - box.lower.z), (box.upper.z - box.lower.z)) + box.lower.z;
                    
                    block_type* blk = target->get_block_integral(xm, ym, zm);
                    target->set_block_integral(x, y, z, *blk);
                }
            }
        }
        
        current_stage = ScanStages::SELECTED;
    }
    current_stage = ScanStages::SETTING_LOWER;
    return true;
}
コード例 #21
0
void Deform_With_Seg::VisualSeg()
{
	vector<ivec3> color_list;
	color_list.clear();
	for(int  i =0; i < total_seg_size; i++)
	{
		color_list.push_back(ivec3((int)(255*(float)(rand())/RAND_MAX),(int)(255*(float)(rand())/RAND_MAX),(int)(255*(float)(rand())/RAND_MAX)));
	}
	for(size_t i = 0; i < target_sample.size(); i++)
	{
		int max_index = 0;
		float max_pro = FLT_MIN;
		for(size_t j = 0; j < target_seg_prob[i].size(); j++)
		{
			if(target_seg_prob[i][j] > max_pro)
			{
				max_pro = target_seg_prob[i][j];
				max_index = j;
			}
		}
		if(max_pro *total_seg_size < 1 )
		{
			//cout << "err" << endl;
			//cout <<"weight_ " << i<<" "; 
			//for (size_t ind = 0; ind < total_seg_size; ind++)
			//{
				//cout << target_seg_prob[i][ind]<<" ";
			//}
			//cout << endl;
			FixSef(i);
			for(size_t j = 0; j < target_seg_prob[i].size(); j++)
			{
				if(target_seg_prob[i][j] > max_pro)
				{
					max_pro = target_seg_prob[i][j];
					max_index = j;
				}
			}
		}
		target_sample[i].color = color_list[max_index];
		target_sample[i].face_id = max_index;
	}
}
コード例 #22
0
void swizzledWalk(int &n, float *gridData, ivec3 pos, ivec3 size, const vec3 &cubeSize){
	if(size.x>1){
		ivec3 newSize=size/2;

		swizzledWalk(n, gridData, pos, newSize, cubeSize);
		swizzledWalk(n, gridData, pos+ivec3(newSize.x, 0, 0), newSize, cubeSize);
		swizzledWalk(n, gridData, pos+ivec3(0, newSize.y,0), newSize, cubeSize);
		swizzledWalk(n, gridData, pos+ivec3(newSize.x, newSize.y, 0), newSize, cubeSize);

		swizzledWalk(n, gridData, pos+ivec3(0, 0, newSize.z), newSize, cubeSize);
		swizzledWalk(n, gridData, pos+ivec3(newSize.x, 0, newSize.z), newSize, cubeSize);
		swizzledWalk(n, gridData, pos+ivec3(0, newSize.y, newSize.z), newSize, cubeSize);
		swizzledWalk(n, gridData, pos+ivec3(newSize.x, newSize.y, newSize.z), newSize, cubeSize);
	}else{
		gridData[n]=(pos.x/cubeSize.x)*2.0f-1.0f;
		gridData[n+1]=(pos.y/cubeSize.y)*2.0f-1.0f;
		gridData[n+2]=(pos.z/cubeSize.z)*2.0f-1.0f;
		n+=3;
	}
}
コード例 #23
0
ファイル: freetype-gl.cpp プロジェクト: andrew-pa/gluk
    // ------------------------------------------------------ texture_atlas_new ---
    texture_atlas_t *
    texture_atlas_new( const size_t width,
                       const size_t height,
                       const size_t depth )
    {
        texture_atlas_t *self = (texture_atlas_t *) malloc( sizeof(texture_atlas_t) );

        // We want a one pixel border around the whole atlas to avoid any artefact when
        // sampling texture
        ivec3 node = ivec3(1,1,width-2);

        assert( (depth == 1) || (depth == 3) || (depth == 4) );
        if( self == NULL)
        {
            fprintf( stderr,
                     "line %d: No more memory for allocating data\n", __LINE__ );
            exit( EXIT_FAILURE );
        }
        self->nodes = vector_new( sizeof(ivec3) );
        self->used = 0;
        self->width = width;
        self->height = height;
        self->depth = depth;
        self->id = 0;

        vector_push_back( self->nodes, &node );
        self->data = (unsigned char *)
            calloc( width*height*depth, sizeof(unsigned char) );

        if( self->data == NULL)
        {
            fprintf( stderr,
                     "line %d: No more memory for allocating data\n", __LINE__ );
            exit( EXIT_FAILURE );
        }

        return self;
    }
コード例 #24
0
int main()
{
    void (*pfi)( int ) = print_elements;

    int ia1[6] = { 1,3,5,7,9,12 };
    int ia2[8] = { 0,1,1,2,3,5,8,13 };
    int ia3[3] = { 1,3,9 };
    int ia4[4] = { 1,3,5,7 };
    int ia5[2] = { 2,4 };

    vector<int> ivec1( ia1, ia1+6 );
    vector<int> ivec2( ia2, ia2+8 );
    vector<int> ivec3( ia3, ia3+3 );
    vector<int> ivec4( ia4, ia4+4 );
    vector<int> ivec5( ia5, ia5+2 );

    cout << "ivec1: "; for_each( ivec1.begin(), ivec1.end(), pfi ); cout << "\n";
    cout << "ivec2: "; for_each( ivec2.begin(), ivec2.end(), pfi ); cout << "\n";
    cout << "ivec3: "; for_each( ivec3.begin(), ivec3.end(), pfi ); cout << "\n";
    cout << "ivec4: "; for_each( ivec4.begin(), ivec4.end(), pfi ); cout << "\n";
    cout << "ivec5: "; for_each( ivec5.begin(), ivec5.end(), pfi ); cout << "\n\n";

    cout << "ivec1 < ivec2 " << (ivec1 < ivec2 ? "true" : "false") << "\n";
    cout << "ivec2 < ivec1 " << (ivec2 < ivec1 ? "true" : "false") << "\n\n";

    cout << "ivec1 < ivec3 " << (ivec1 < ivec3 ? "true" : "false") << "\n";
    cout << "ivec1 < ivec4 " << (ivec1 < ivec4 ? "true" : "false") << "\n";
    cout << "ivec1 < ivec5 " << (ivec1 < ivec5 ? "true" : "false") << "\n\n";

    cout << "ivec1 == ivec1 " << (ivec1 == ivec1 ? "true" : "false") << "\n";
    cout << "ivec1 == ivec4 " << (ivec1 == ivec4 ? "true" : "false") << "\n";
    cout << "ivec1 != ivec4 " << (ivec1 != ivec4 ? "true" : "false") << "\n\n";

    cout << "ivec1 > ivec2 "  << (ivec1 > ivec2  ? "true" : "false") << "\n";
    cout << "ivec3 > ivec1 "  << (ivec3 > ivec1  ? "true" : "false") << "\n";
    cout << "ivec5 > ivec2 "  << (ivec5 > ivec2  ? "true" : "false") << "\n";
}    
コード例 #25
0
bool GetArrayIndex(vec3 index, out ivec3 arrayIndex)
{

	ivec3 chunk;
	chunk.x = int(floor(index.x / chunk_size));
	chunk.y = int(floor(index.y / chunk_size));
	chunk.z = int(floor(index.z / chunk_size));

	chunk.x -= (index.x < 0) ? 1 : 0;
	chunk.y -= (index.y < 0) ? 1 : 0;
	chunk.z -= (index.z < 0) ? 1 : 0;
		
	if(
		((chunk.x + 1) < offset.x) ||
		((chunk.x + 1) > (offset.x + world_size)) ||
		((chunk.y + 1) < offset.y) ||
		((chunk.y + 1) > (offset.y + world_size)) ||
		((chunk.z + 1) < offset.z) || 
		((chunk.z + 1) > (offset.z + world_size))
		)
	{
		return false; // Check if block is invalid, i.e. outside the world
	}

	chunk.x = eMod(chunk.x, world_size);
	chunk.y = eMod(chunk.y, world_size);
	chunk.z = eMod(chunk.z, world_size);

	ivec3 block = ivec3(index);
	
	block.x = eMod(block.x, chunk_size);
	block.y = eMod(block.y, chunk_size);
	block.z = eMod(block.z, chunk_size);

	arrayIndex = (chunk * chunk_size + block);
	return true;
}
コード例 #26
0
int main(int argc, const char *argv[])
{
    // Item 46. Consider function objects instead of functions as algorithm parameters. [ effective stl ] 
    // because we can define function operator as inline function, and the compiler is not optimize for functions even if you 
    // specify it as inline function
    int a[] = {1, 2, 3, 4};
    std::vector<int> ivec(a, a + sizeof(a)/sizeof(int));
    std::for_each(ivec.begin(), ivec.end(), Double<int>()); 
    std::for_each(ivec.begin(), ivec.end(), print<int>);   
    std::cout << std::endl;
    std::for_each(ivec.begin(), ivec.end(), doubleFun<int>); 
    std::for_each(ivec.begin(), ivec.end(), print<int>);   
    std::cout << std::endl;

    // liner search function, find and find_if      
    // for random iterator, find algorithm use loop expand to optimize       

    typedef std::vector<int>::iterator IVecInterator;
    IVecInterator iter = find(ivec.begin(), ivec.end(), 5); 
    if (iter == ivec.end()) {
        std::cout << "could not find 5 in the vector ivec" << std::endl;
    }

    // similar with assocative container, they both have count and find member function. there is also count algorithm
    // count, count_if 
    
    std::cout << "there is " << std::count(ivec.begin(), ivec.end(), 5) << " in the vector ivec" << std::endl;

    // search the first same or last same value in the two ranges 
    int b[] = {4, 3, 3, 5, 4}; 
    std::vector<int> ivec2(b, b + sizeof(b)/sizeof(int));
    // return the first element in range 2 which occur in the range 1, 
    // in this example, range1 is "4, 8, 12, 16", range 2 is "4, 3, 3, 5, 4"
    // so return 4
    IVecInterator firstIter = find_first_of(ivec.begin(), ivec.end(), ivec2.begin(), ivec2.end());
    if (firstIter != ivec.end()) {
        std::cout << *firstIter << std::endl;
    }

    IVecInterator secondIter = find_end(ivec.begin(), ivec.end(), ivec2.begin(), ivec2.end()); 
    if (secondIter != ivec.end()) {
        std::cout << *secondIter << std::endl;
    }

    // find subsequence algorithm
    // adjacent_find ,return the first duplicated element which are adjacent,otherwise return end
    IVecInterator adjacent = adjacent_find(ivec2.begin(), ivec2.end()); 
    if (adjacent != ivec2.end()) {
        std::cout << *adjacent << std::endl;
    }

    // search subsequence 
    int c[] = {3, 5, 4};
  
    std::vector<int> ivec3(c, c + sizeof(c)/sizeof(int)); 
    IVecInterator subsequence = search(ivec2.begin(), ivec2.end(), ivec3.begin(), ivec3.end()); 
    if (subsequence != ivec2.end()) {
        std::cout << *subsequence << std::endl;
    }

//    IVecInterator n = search_n(ivec3.begin(), ivec3.end(), 

    // binary search          
   
    // write only alogrithm  
    // fill_n(dest, cnt, val)

    // generate_n(dest, cnt, Gen)

    // copy(beg, end, dest)

    // transform(beg, end, dest, unaryOp)
    // transform(beg, end, beg2, dest, binaryOp)

    // merge(beg1, end1, beg2, end2, dest)
    // merge(beg1, end1, beg2, end2, dest, comp)

    // sort and partition algorithm    
    // partition, stable_partition
    // stable_partition(beg, end, unaryPred)
    // partition(beg, end, unaryPred)
  
   
    // sort, stable_sort, partitial_sort
    
    // nth_element  

    // general reorder algorithm
    // unique, reverse, rotate, remove, remove_if

    // remove_copy, unique_copy, rotate_copy, random_shuffle

    // permutation alogrithm
    // prev_permutation(beg, end), next_permutation(beg, end)
    int a5[] = {1, 2, 3, 4};
    std::vector<int> ivec5(a5, a5 + 4);

    // alogrithm for next_permutation :     
    std::next_permutation(ivec5.begin(), ivec5.end());
    std::for_each(ivec5.begin(), ivec5.end(), print<int>);
    std::cout << std::endl;
    std::next_permutation(ivec5.begin(), ivec5.end());
    std::for_each(ivec5.begin(), ivec5.end(), print<int>);
    std::cout << std::endl;


    // ordered set algorithm : set_union, set_intersection, set_difference, set_symmetric_difference

    // compare algorithm
    // min(val1, val2), max(val1, val2), min_element, max_element(beg, end)

    // math algorithm
    
    return 0;
}
コード例 #27
0
ファイル: mrcvolumereader.cpp プロジェクト: molsimmsu/3mview
VolumeCollection* MRCVolumeReader::read(const std::string &url)
    throw (tgt::FileException, tgt::IOException, std::bad_alloc)
{
    VolumeCollection* volumeCollection = new VolumeCollection();

    VolumeURL origin(url);
    std::string fileName = origin.getPath();
    LINFO(fileName);
    
    std::ifstream mrc;
    mrc.open(fileName.c_str(), std::ios::binary);
    if (!mrc.is_open()) {
        LWARNING("Can't open stream");
    }
    else {
        int dim[3]; // grid dimensions i.e. numbers of voxels for each dimension
        mrc.read((char*)(&dim), sizeof(dim));
        std::cout << "X: " << dim[0] << std::endl; // number of columns (fastest changing in map)
        std::cout << "Y: " << dim[1] << std::endl; // number of rows
        std::cout << "Z: " << dim[2] << std::endl; // number of sections (slowest changing in map)
        
        int numVoxels = dim[0] * dim[1] * dim[2]; // total number of voxels in volume
        std::cout << "numVoxels: " << numVoxels << std::endl;
        
        int dataType; // see below
        mrc.read((char*)(&dataType), sizeof(dataType));
        std::cout << "dataType: " << dataType << std::endl;
        
        int dataSize = 0; // i.e. 8-bit, 16-bit or 32-bit
             if (dataType == 0) dataSize = 1; // signed 8-bit bytes range -128 to 127
        else if (dataType == 1) dataSize = 2; // 16-bit halfwords
        else if (dataType == 2) dataSize = 4; // 32-bit reals
        else if (dataType == 6) dataSize = 2; // unsigned 16-bit range 0 to 65535
        
        tgtAssert(dataSize, "Datasize is 0 at MRCVolumeReader::read()");
        
        int totalDataSize = dataSize * numVoxels;
        
        int start[3]; // numbers of first columns i.e. offset of the volume origin in voxel coordinates
        mrc.read((char*)(&start), sizeof(start));
        std::cout << "startX: " << start[0] << std::endl; // number of columns (fastest changing in map)
        std::cout << "startY: " << start[1] << std::endl; // number of rows
        std::cout << "startZ: " << start[2] << std::endl; // number of sections (slowest changing in map)

        int gridSize[3];
        mrc.read((char*)(&gridSize), sizeof(gridSize));
        std::cout << "gridSizeX: " << gridSize[0] << std::endl;
        std::cout << "gridSizeY: " << gridSize[1] << std::endl; 
        std::cout << "gridSizeZ: " << gridSize[2] << std::endl;
     
        float cellDimensions[3]; // cell dimensions in angstroms
        mrc.read((char*)(&cellDimensions), sizeof(cellDimensions));
        std::cout << "cellX: " << cellDimensions[0] << std::endl; 
        std::cout << "cellY: " << cellDimensions[1] << std::endl; 
        std::cout << "cellZ: " << cellDimensions[2] << std::endl; 
        
        float scale[3]; // pixelSpacing i.e. scale from voxel to real-word coordinates
        scale[0] = cellDimensions[0] / gridSize[0];
        scale[1] = cellDimensions[1] / gridSize[1];
        scale[2] = cellDimensions[2] / gridSize[2];
        std::cout << "pixelSpacingX: " << scale[0] << std::endl; 
        std::cout << "pixelSpacingY: " << scale[1] << std::endl; 
        std::cout << "pixelSpacingZ: " << scale[2] << std::endl; 
        
        float angles[3]; // cell angles in degrees
        mrc.read((char*)(&angles), sizeof(angles));
        std::cout << "cellAngleX: " << angles[0] << std::endl;
        std::cout << "cellAngleY: " << angles[1] << std::endl;
        std::cout << "cellAngleZ: " << angles[2] << std::endl;
        
        int axes[3]; // Which axis corresponds to columns, rows and sections (1,2,3 for X,Y,Z)
        mrc.read((char*)(&axes), sizeof(axes));
        std::cout << "axesX: " << axes[0] << std::endl;
        std::cout << "axesY: " << axes[1] << std::endl; 
        std::cout << "axesZ: " << axes[2] << std::endl; 
        
        float origin[3];
        mrc.seekg(4*49, std::ios::beg);
        mrc.read((char*)(&origin), sizeof(origin));
        std::cout << "originX: " << origin[0] << std::endl; 
        std::cout << "originY: " << origin[1] << std::endl; 
        std::cout << "originZ: " << origin[2] << std::endl; 
        
        void* data = malloc(totalDataSize);
        mrc.seekg(1024, std::ios::beg);
        mrc.read((char*)data, totalDataSize);
        mrc.close();
        
        VolumeRAM* targetDataset;
        
        int a = axes[0]-1;
        int b = axes[1]-1;
        int c = axes[2]-1;
        
        /**/ if (dataType == 0) {
            targetDataset = new VolumeAtomic<int8_t>(ivec3(dim[a], dim[b], dim[c]));
            fillVolume<int8_t>(targetDataset, data, dim, axes);
        }
        else if (dataType == 1) {
            targetDataset = new VolumeAtomic<int16_t>(ivec3(dim[a], dim[b], dim[c]));
            fillVolume<int16_t>(targetDataset, data, dim, axes);
        }
        else if (dataType == 2) {
            targetDataset = new VolumeAtomic<float>(ivec3(dim[a], dim[b], dim[c]));
            fillVolume<float>(targetDataset, data, dim, axes);
        }
        else if (dataType == 6) {
            targetDataset = new VolumeAtomic<uint16_t>(ivec3(dim[a], dim[b], dim[c]));
            fillVolume<uint16_t>(targetDataset, data, dim, axes);
        }
        else LERROR("Unsupported data type at MRCVolumeReader::read()");
            
        free(data);
        
        angles[0] *= (PI / 180.);
        angles[1] *= (PI / 180.);
        angles[2] *= (PI / 180.);
        
        float row[3][3];
        
        // X
        row[0][0] = 1;
        row[0][1] = 0;
        row[0][2] = 0;
        
        // Y
        row[1][0] = cos(angles[2]); // cos(gamma)
        row[1][1] = sin(angles[2]); // sin(gamma)
        row[1][2] = 0;
        
        // Z
        row[2][0] = cos(angles[1]); // cos(beta)
        row[2][1] = (cos(angles[0]) - row[2][0] * row[1][0]) / row[1][1];  // [cos(alpha) - cos(beta)*cos(gamma)] / sin(gamma)
        row[2][2] = sqrt(1 - row[2][0] * row[2][0] - row[2][1] * row[2][1]); // squared length is 1
        
        tgt::Matrix4<float> transform
        (
            row[0][0], row[1][0], row[2][0], 0,
            row[0][1], row[1][1], row[2][1], 0,
            row[0][2], row[1][2], row[2][2], 0,
            0.0f, 0.0f, 0.0f, 1.0f
        );
        
        Volume* volumeHandle = new MoleculeVolume(
            targetDataset,                                                 // data
            vec3(scale[a], scale[b], scale[c]),                            // scale
            vec3(start[a]*scale[a], start[b]*scale[b], start[c]*scale[c]), // offset
            transform                                                      // transform
        );
        
        volumeCollection->add(volumeHandle);
    }
    
    if (!volumeCollection->empty())
        volumeCollection->first()->setOrigin(VolumeURL(fileName));
        
    return volumeCollection;
}
コード例 #28
0
ファイル: ImageTools.cpp プロジェクト: spykedood/Oh-My-Buddha
ivec3 ImageData::getColor(unsigned int x, unsigned int y) const
{
	int idx = (y * w + x) * d;
	return ivec3( data[idx+0], data[idx+1], data[idx+2]);
}
コード例 #29
0
//Software marching cubes
//VERY far to be optimal !
void MarchingCubesRenderer::RenderMarchCube(float *data, ivec3 size, ivec3 gridsize, float isolevel){
  vec3 gridStep = vec3(2.0, 2.0, 2.0) / vec3(gridsize.x, gridsize.y, gridsize.z);

  ivec3 dataGridStep = size / gridsize;

  vec3 *triangles = new vec3[16];
  
  std::vector<Vector3>& positions = _mesh->getPositionVector();
  positions.clear();

  for (int k = 0; k < gridsize.z - 1; k++)
  for (int j = 0; j < gridsize.y - 1; j++)
  for (int i = 0; i < gridsize.x - 1; i++){
    GridCell cell;
    vec3 vcurf(i, j, k);
    ivec3 vcuri(i, j, k);

    cell.pos[0] = vcurf*gridStep - 1.0f;
    ivec3 valPos0 = vcuri*dataGridStep;
    cell.val[0] = data[valPos0.x + valPos0.y*size.x + valPos0.z*size.x*size.y];

    ivec3 valPos;

    cell.pos[1] = cell.pos[0] + vec3(gridStep.x, 0, 0);
    if (i == gridsize.x - 1)
      valPos = valPos0;
    else
      valPos = valPos0 + ivec3(dataGridStep.x, 0, 0);
    cell.val[1] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];

    cell.pos[2] = cell.pos[0] + vec3(gridStep.x, gridStep.y, 0);
    valPos = valPos0 + ivec3(i == gridsize.x - 1 ? 0 : dataGridStep.x, j == gridsize.y - 1 ? 0 : dataGridStep.y, 0);
    cell.val[2] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];

    cell.pos[3] = cell.pos[0] + vec3(0, gridStep.y, 0);
    valPos = valPos0 + ivec3(0, j == gridsize.y - 1 ? 0 : dataGridStep.y, 0);
    cell.val[3] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];


    cell.pos[4] = cell.pos[0] + vec3(0, 0, gridStep.z);
    valPos = valPos0 + ivec3(0, 0, k == gridsize.z - 1 ? 0 : dataGridStep.z);
    cell.val[4] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];


    cell.pos[5] = cell.pos[0] + vec3(gridStep.x, 0, gridStep.z);
    valPos = valPos0 + ivec3(i == gridsize.x - 1 ? 0 : dataGridStep.x, 0, k == gridsize.z - 1 ? 0 : dataGridStep.z);
    cell.val[5] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];

    cell.pos[6] = cell.pos[0] + vec3(gridStep.x, gridStep.y, gridStep.z);
    valPos = valPos0 + ivec3(i == gridsize.x - 1 ? 0 : dataGridStep.x, j == gridsize.y - 1 ? 0 : dataGridStep.y, k == gridsize.z - 1 ? 0 : dataGridStep.z);
    cell.val[6] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];

    cell.pos[7] = cell.pos[0] + vec3(0, gridStep.y, gridStep.z);
    valPos = valPos0 + ivec3(0, j == gridsize.y - 1 ? 0 : dataGridStep.y, k == gridsize.z - 1 ? 0 : dataGridStep.z);
    cell.val[7] = data[valPos.x + valPos.y*size.x + valPos.z*size.x*size.y];


    int numvert = Polygonise(cell, isolevel, triangles);

    //Put the triangles into the mesh
    for (int n = 0; n < numvert; n++){
      positions.push_back(Vector3(triangles[n].x, triangles[n].y, triangles[n].z));
    }


  }
  if (positions.empty() == false)
  {
    GetGLError();
    _mesh->constructBuffer();
    GetGLError();
    _mesh->drawBuffers();
    GetGLError();
  }
}
コード例 #30
0
void MarchingCubesRenderer::draw()
{
	//States setting
	//glEnable(GL_DEPTH_TEST);
	//glDisable(GL_ALPHA_TEST);

  /*
  vec3 eye = vec3(0, 0, 3);
  vec3 up(0, 1, 0); vec3 target(0, 0, 0);
  mat4 mv =glm::lookAt(eye, target, up);

	//Activate modelview
  mv = mv * glm::rotate(GLFWTime::getCurrentTime()*0.5f, vec3(0, 1, 0));
  //mv = glm::rotate(this->viewOrient.y * 10, vec3(0, 1, 0));

  Vector2 size = RenderManager::getInstance().getFramebufferSize();
  float aspect = size.x / size.y;

  float n = 0.01f;
  float f = 100.0f;
  float fieldOfView = 0.7f;// 1.74532925f;//100 degrees

  mat4 projection = glm::perspective(fieldOfView, aspect, n, f);

  mat4 mvp = projection*mv;

  */
  mat4 m = glm::rotate(GLFWTime::getCurrentTime()*0.5f, vec3(0, 1, 0));
  //FROM RENDERER
  Camera& cam = RenderManager::getInstance().getMainCamera();
  mat4 view = cam.getModelview();
  mat4 proj = cam.getProjection();
  mat4 mv = view *m;
  mat4 mvp = proj * mv;

  GetGLError();
  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_3D, this->dataFieldTex[curData]);
  glActiveTexture(GL_TEXTURE1);
  glBindTexture(GL_TEXTURE_2D, this->edgeTableTex);
  glActiveTexture(GL_TEXTURE2);
  glBindTexture(GL_TEXTURE_2D, this->triTableTex);
  
  GetGLError();

  isolevel = (sin(GLFWTime::getCurrentTime() * 1.5f) + 1.0f) * 0.02f + 0.45f;
  //isolevel = (sin(GLFWTime::getCurrentTime() * 0.5f) + 1.0f) * 0.2f + 0.4f;
  //printf("%3.4f\n", isolevel);

  if(mode != 0){
		if(mode==1){
			//Shader program binding

      programObject.bind();


      _texture.bindToChannel(0);
      programObject.setUniform("dataFieldTex", 0);
      programObject.setUniform("edgeTableTex", 1);
      programObject.setUniform("triTableTex", 2);
			programObject.setUniform("isolevel", isolevel); 
      programObject.setUniform("mvp", mvp);
      programObject.setUniform("ModelViewProjection", mvp);
      //Decal for each vertex in a marching cube
      programObject.setUniform("vertDecals[0]", vec3(0.0f, 0.0f, 0.0f));
      programObject.setUniform("vertDecals[1]", vec3(cubeStep.x, 0.0f, 0.0f));
      programObject.setUniform("vertDecals[2]", vec3(cubeStep.x, cubeStep.y, 0.0f));
      programObject.setUniform("vertDecals[3]", vec3(0.0f, cubeStep.y, 0.0f));
      programObject.setUniform("vertDecals[4]", vec3(0.0f, 0.0f, cubeStep.z));
      programObject.setUniform("vertDecals[5]", vec3(cubeStep.x, 0.0f, cubeStep.z));
      programObject.setUniform("vertDecals[6]", vec3(cubeStep.x, cubeStep.y, cubeStep.z));
      programObject.setUniform("vertDecals[7]", vec3(0.0f, cubeStep.y, cubeStep.z));
      programObject.setUniform("vertDecals[0]", vec3(0.0f, 0.0f, 0.0f));
		}else{
			//Shader program binding
      programObjectGS.bind();
      programObjectGS.setUniform("dataFieldTex", 0);
      programObjectGS.setUniform("edgeTableTex", 1);
      programObjectGS.setUniform("triTableTex", 2);
      programObjectGS.setUniform("isolevel", isolevel);
      programObjectGS.setUniform("mvp", mvp);
      programObjectGS.setUniform("ModelViewProjection", mvp);
		}	

		//glEnable(GL_LIGHTING);

		//Switch to wireframe or solid rendering mode
		//if(wireframe)
		//	glPolygonMode(GL_FRONT_AND_BACK , GL_LINE );
		//else
		//	glPolygonMode(GL_FRONT_AND_BACK , GL_FILL );


    _meshGS->drawBuffers();
   
  	}else{
      //THIS IS SOFTWARE MARCHING CUBES
  		programObjectFS.bind();
      glActiveTexture(GL_TEXTURE0 );
      glBindTexture(GL_TEXTURE_3D, this->dataFieldTex[curData]);
      programObjectFS.setUniform("dataFieldTex", 0);
      programObjectFS.setUniform("mvp", mvp);
      programObjectFS.setUniform("ModelViewProjection", mvp);
      programObjectFS.setUniform("ModelView", mv);
      GetGLError();
  		RenderMarchCube(dataField[curData], ivec3(128,128,128), ivec3(cubeSize.x, cubeSize.y, cubeSize.z), isolevel);
      GetGLError();
      programObjectFS.unbind();
  	}
  }