Example #1
0
	void Renderer::setBuffers( Mesh& mesh )
	{
		UInt32 stride = sizeof( Vertex );
		UInt32 offset = 0;
		setVertexBuffers( &mesh._vertexBuffer, &stride, &offset );
		setIndexBuffer( &mesh._indexBuffer );
	}
Example #2
0
//------------------------------------------------------------------------------
//## Basic
TEST_F(Test_Shader_Shader, IndependentSamplerState)
{
    auto shader1 = Shader::create(LN_ASSETFILE("Shader/IndependentSamplerState.fx"));

    auto vertexDecl1 = newObject<VertexLayout>();
    vertexDecl1->addElement(0, VertexElementType::Float3, VertexElementUsage::Position, 0);
    vertexDecl1->addElement(0, VertexElementType::Float2, VertexElementUsage::TexCoord, 0);

    struct Vertex
    {
        Vector3 pos;
        Vector2 uv;
    };
    Vertex v[] = {
        { { -1, 1, 0 }, { 0, 0 }, },	// 0.5 で中央の face からサンプリングする
        { { 0, 1, 0 }, { 1, 0 }, },
        { { -1, 0, 0 }, { 0, 1 }, },
        { { 0, 0, 0 }, { 1, 1 }, },
    };
    auto vb1 = newObject<VertexBuffer>(sizeof(v), v, GraphicsResourceUsage::Static);

    auto tex1 = newObject<Texture2D>(2, 2, TextureFormat::RGBA8);
    auto bmp1 = tex1->map(MapMode::Write);
    bmp1->setPixel32(0, 0, ColorI(255, 0, 0, 255));
    bmp1->setPixel32(1, 0, ColorI(255, 0, 255, 255));
    bmp1->setPixel32(0, 1, ColorI(0, 255, 0, 255));
    bmp1->setPixel32(1, 1, ColorI(0, 0, 255, 255));

    // TODO: まだ SamplerState 直接指定をサポートしていないので Texture に対してセットする方法でテストケースだけ用意しておく。
    // 後でサポートするとき、shader1->findParameter("mySamplerState")->setSamplerState(samplerState); とかに書き換える。
    auto samplerState = newObject<SamplerState>();
    samplerState->setFilterMode(TextureFilterMode::Linear);
    tex1->setSamplerState(samplerState);

    shader1->findParameter("_Texture")->setTexture(tex1);

    auto ctx = Engine::graphicsContext();
    TestEnv::resetGraphicsContext(ctx);
    ctx->setVertexLayout(vertexDecl1);
    ctx->setVertexBuffer(0, vb1);
    ctx->setIndexBuffer(nullptr);
    ctx->setShaderPass(shader1->techniques()[0]->passes()[0]);

    // * [ ] default
    {
        ctx->clear(ClearFlags::All, Color::White, 1.0f, 0);
		ctx->setPrimitiveTopology(PrimitiveTopology::TriangleStrip);
        ctx->drawPrimitive(0, 2);

        ASSERT_SCREEN(LN_ASSETFILE("Shader/Result/Test_Shader_Shader-IndependentSamplerState-1.png"));
    }
}
Example #3
0
void mirror::setData(ID3D11Device *_m_d3d11Device,float _width, float _height, float _left, float _top)
{
	m_d3d11Device = _m_d3d11Device;
	left = _left;
	top = _top;
	width = _width;
	height = _height;

	float cameraZ = 0;


	//********************m_backMirror_VERTEX	
	m_backMirror_VERTEX[0].xyz.x = left;
	m_backMirror_VERTEX[0].xyz.y = top;
	m_backMirror_VERTEX[0].xyz.z = cameraZ;
	m_backMirror_VERTEX[0].uvw.x = 0;
	m_backMirror_VERTEX[0].uvw.y = 0;
	m_backMirror_VERTEX[0].uvw.z = 0;

	m_backMirror_VERTEX[1].xyz.x = m_backMirror_VERTEX[0].xyz.x + width;
	m_backMirror_VERTEX[1].xyz.y = m_backMirror_VERTEX[0].xyz.y;
	m_backMirror_VERTEX[1].xyz.z = cameraZ;
	m_backMirror_VERTEX[1].uvw.x = 1;
	m_backMirror_VERTEX[1].uvw.y = 0;
	m_backMirror_VERTEX[1].uvw.z = 0;

	m_backMirror_VERTEX[2].xyz.x = m_backMirror_VERTEX[0].xyz.x + width;
	m_backMirror_VERTEX[2].xyz.y = m_backMirror_VERTEX[0].xyz.y - height;
	m_backMirror_VERTEX[2].xyz.z = cameraZ;
	m_backMirror_VERTEX[2].uvw.x = 1;
	m_backMirror_VERTEX[2].uvw.y = 1;
	m_backMirror_VERTEX[2].uvw.z = 0;

	m_backMirror_VERTEX[3].xyz.x = m_backMirror_VERTEX[0].xyz.x;
	m_backMirror_VERTEX[3].xyz.y = m_backMirror_VERTEX[0].xyz.y - height;
	m_backMirror_VERTEX[3].xyz.z = cameraZ;
	m_backMirror_VERTEX[3].uvw.x = 0;
	m_backMirror_VERTEX[3].uvw.y = 1;
	m_backMirror_VERTEX[3].uvw.z = 0;

	for (int i = 0; i < 4; i++)
	{
		m_backMirror_VERTEX[i].nrm.x = 0;
		m_backMirror_VERTEX[i].nrm.y = 0;
		m_backMirror_VERTEX[i].nrm.z = -1;
	}
	unsigned int mirror_indicies[6] = { 0, 2, 3, 0, 1, 2 };

	setVertexBuffer(m_backMirror_VERTEX, rectNumber);
	setIndexBuffer(mirror_indicies, rectIndexNumber);
}
Example #4
0
void mirror::setPos(ID3D11Device *_m_d3d11Device, const XMFLOAT2& topleft, const XMFLOAT2& topright, const XMFLOAT2& botright, const XMFLOAT2& botleft)
{
	m_d3d11Device = _m_d3d11Device;
	float cameraZ = 0;

	//********************m_backMirror_VERTEX	
	//topleft
	m_backMirror_VERTEX[0].xyz.x = topleft.x;
	m_backMirror_VERTEX[0].xyz.y = topleft.y;
	m_backMirror_VERTEX[0].xyz.z = cameraZ;
	m_backMirror_VERTEX[0].uvw.x = 0;
	m_backMirror_VERTEX[0].uvw.y = 0;
	m_backMirror_VERTEX[0].uvw.z = 0;

	//top right
	m_backMirror_VERTEX[1].xyz.x = topright.x;
	m_backMirror_VERTEX[1].xyz.y = topright.y;
	m_backMirror_VERTEX[1].xyz.z = cameraZ;
	m_backMirror_VERTEX[1].uvw.x = 1;
	m_backMirror_VERTEX[1].uvw.y = 0;
	m_backMirror_VERTEX[1].uvw.z = 0;

	//bot right
	m_backMirror_VERTEX[2].xyz.x = botright.x;
	m_backMirror_VERTEX[2].xyz.y = botright.y;
	m_backMirror_VERTEX[2].xyz.z = cameraZ;
	m_backMirror_VERTEX[2].uvw.x = 1;
	m_backMirror_VERTEX[2].uvw.y = 1;
	m_backMirror_VERTEX[2].uvw.z = 0;

	//bot left
	m_backMirror_VERTEX[3].xyz.x = botleft.x;
	m_backMirror_VERTEX[3].xyz.y = botleft.y;
	m_backMirror_VERTEX[3].xyz.z = cameraZ;
	m_backMirror_VERTEX[3].uvw.x = 0;
	m_backMirror_VERTEX[3].uvw.y = 1;
	m_backMirror_VERTEX[3].uvw.z = 0;

	for (int i = 0; i < 4; i++)
	{
		m_backMirror_VERTEX[i].nrm.x = 0;
		m_backMirror_VERTEX[i].nrm.y = 0;
		m_backMirror_VERTEX[i].nrm.z = -1;
	}
	unsigned int mirror_indicies[6] = { 0, 2, 3, 0, 1, 2 };

	setVertexBuffer(m_backMirror_VERTEX, rectNumber);
	setIndexBuffer(mirror_indicies, rectIndexNumber);
}
Example #5
0
void ShadowsDemo::onDraw() {
	App::onDraw();

	const auto device = graphicsDevice();

	device->setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	device->clear(ciri::ClearFlags::Color | ciri::ClearFlags::Depth);

	device->setRasterizerState(_rasterState);
	device->restoreDefaultBlendState();

	if( _spotlightShader->isValid() && _directionalShader->isValid() ) {
		const cc::Mat4f& cameraViewProj = _camera.getProj() * _camera.getView();

		bool firstLight = true;
		Light::Type boundLightType = Light::Type::Invalid;
		for( auto& light : _lights ) {
			// compute light matrices
			//const cc::Mat4f& lightView = light.view();
			//const cc::Mat4f& lightProj = light.proj();//cc::math::perspectiveRH(45.0f, 1.0f, 0.1f, light.range());//light.proj();
			//const cc::Mat4f lightViewProj = lightProj * lightView;
			if( light.type() == Light::Type::Directional ) {
				//light.computeViewProjFromFrustum(BoundingFrustum(cameraViewProj));
				light.computeViewProjFromFrustum(BoundingFrustum(_camera.getFov(), _camera.getAspect(), _camera.getNearPlane(), _camera.getFarPlane(), _camera.getPosition(), _camera.getFpsFront(), _camera.getUp()));
				//light.computeViewProjOrtho(_camera.getView(), _camera.getFov(), _camera.getAspect(), _camera.getNearPlane(), _camera.getFarPlane());
			}
			const cc::Mat4f lightViewProj = light.proj() * light.view();

			if( light.castShadows() ) {
				device->setDepthStencilState(device->getDefaultDepthStencilDefault());
				// set and clear render target
				ciri::IRenderTarget2D* depthTarget = _shadowTarget.get();
				device->setRenderTargets(&depthTarget, 1);
				device->setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
				device->clear(ciri::ClearFlags::Color | ciri::ClearFlags::Depth);
				// apply depth shader
				device->applyShader(_depthShader);
				// set viewport to depth size
				device->setViewport(ciri::Viewport(0, 0, _shadowTarget->getDepth()->getWidth(), _shadowTarget->getDepth()->getHeight()));
				// render all models
				for( auto& mdl : _models ) {
					_depthConstants.xform = lightViewProj * mdl->getXform().getWorld();
					_depthConstantsBuffer->setData(sizeof(DepthConstants), &_depthConstants);
					device->setVertexBuffer(mdl->getVertexBuffer());
					if( mdl->getIndexBuffer() != nullptr ) {
						device->setIndexBuffer(mdl->getIndexBuffer());
						device->drawIndexed(ciri::PrimitiveTopology::TriangleList, mdl->getIndexBuffer()->getIndexCount());
					} else {
						device->drawArrays(ciri::PrimitiveTopology::TriangleList, mdl->getVertexBuffer()->getVertexCount(), 0);
					}
				}

				// reser viewport to screen
				device->setViewport(ciri::Viewport(0, 0, window()->getWidth(), window()->getHeight()));
				// restore default render targets
				device->restoreDefaultRenderTargets();
			}
			switch( light.type() ) {
				case Light::Type::Directional: {
					if( boundLightType != Light::Type::Directional || light.castShadows() ) {
						boundLightType = Light::Type::Directional;
						device->applyShader(_directionalShader);
						device->setTexture2D(0, _shadowTarget->getDepth(), ciri::ShaderStage::Pixel);
						device->setSamplerState(0, _shadowSampler, ciri::ShaderStage::Pixel);
					}
					_directionalConstants.LightDirection = light.direction();
					_directionalConstants.LightColor = light.diffuseColor();
					_directionalConstants.LightIntensity = light.diffuseIntensity();
					_directionalConstants.campos = _camera.getPosition();
					_directionalConstants.CastShadows = light.castShadows();
					_directionalConstants.lightViewProj = lightViewProj;
					for( auto& mdl : _models ) {
						if( !mdl->isValid() ) {
							continue;
						}
						_directionalConstants.world = mdl->getXform().getWorld();
						_directionalConstants.xform = cameraViewProj * _directionalConstants.world;
						_directionalConstantsBuffer->setData(sizeof(DirectionalConstants), &_directionalConstants);
						device->setVertexBuffer(mdl->getVertexBuffer());
						if( mdl->getIndexBuffer() != nullptr ) {
							device->setIndexBuffer(mdl->getIndexBuffer());
							device->drawIndexed(ciri::PrimitiveTopology::TriangleList, mdl->getIndexBuffer()->getIndexCount());
						} else {
							device->drawArrays(ciri::PrimitiveTopology::TriangleList, mdl->getVertexBuffer()->getVertexCount(), 0);
						}
					}
					break;
				}
				case Light::Type::Spot: {
					if( boundLightType != Light::Type::Spot || light.castShadows() ) {
						boundLightType = Light::Type::Spot;
						device->applyShader(_spotlightShader);
						device->setTexture2D(0, _shadowTarget->getDepth(), ciri::ShaderStage::Pixel);
						device->setSamplerState(0, _shadowSampler, ciri::ShaderStage::Pixel);
					}
					_spotlightConstants.LightPosition = light.position();
					_spotlightConstants.LightDirection = light.direction();
					_spotlightConstants.LightColor = light.diffuseColor();
					_spotlightConstants.LightCosInner = light.cosConeInnerAngle(true);
					_spotlightConstants.LightCosOuter = light.cosConeOuterAngle(true);
					_spotlightConstants.LightIntensity = light.diffuseIntensity();
					_spotlightConstants.LightRange = light.range();
					_spotlightConstants.CastShadows = light.castShadows();
					_spotlightConstants.lightViewProj = lightViewProj;
					for( auto& mdl : _models ) {
						_spotlightConstants.world = mdl->getXform().getWorld();
						_spotlightConstants.xform = cameraViewProj * _spotlightConstants.world;
						_spotlightConstantsBuffer->setData(sizeof(SpotlightConstants), &_spotlightConstants);
						device->setVertexBuffer(mdl->getVertexBuffer());
						if( mdl->getIndexBuffer() != nullptr ) {
							device->setIndexBuffer(mdl->getIndexBuffer());
							device->drawIndexed(ciri::PrimitiveTopology::TriangleList, mdl->getIndexBuffer()->getIndexCount());
						} else {
							device->drawArrays(ciri::PrimitiveTopology::TriangleList, mdl->getVertexBuffer()->getVertexCount(), 0);
						}
					}
					break;
				}
			}

			if( firstLight ) {
				firstLight = false;
				device->setBlendState(_additiveBlendState);
			}
		}
	}

	device->present();
}
Example #6
0
BoxGeometry::BoxGeometry(
		String name,
		const Vector3D& halfExtends,
		bool addTangents,
		bool patchRepresentation,
		const Vector4D& texcoordScale)
: VertexBasedGeometry(name,
		patchRepresentation ? VERTEX_BASED_TRIANGLE_PATCHES : VERTEX_BASED_TRIANGLES),
		mHalfExtends(halfExtends)
  {
	BufferInfo bufferi(
			name + String("BoxGeometryPositionBuffer"),
			ContextTypeFlags(HOST_CONTEXT_TYPE_FLAG | OPEN_GL_CONTEXT_TYPE_FLAG),
			POSITION_SEMANTICS,
			TYPE_VEC4F,
			6* 4 , //because of the normals, the vertices cannot be shared ;(
			BufferElementInfo(4,GPU_DATA_TYPE_FLOAT,32,false),
			VERTEX_ATTRIBUTE_BUFFER_TYPE,
			NO_CONTEXT_TYPE
	);

	setAttributeBuffer(new Buffer(bufferi,false,0));

	bufferi.name = name + String("BoxGeometryNormalBuffer");
	bufferi.bufferSemantics = NORMAL_SEMANTICS;
	setAttributeBuffer(new Buffer(bufferi,false,0));

	if(addTangents)
	{
		bufferi.name = name + String("BoxGeometryTangentBuffer");
		bufferi.bufferSemantics = TANGENT_SEMANTICS;
		setAttributeBuffer( new Buffer( bufferi, false, 0 )	);
	}

	bufferi.name = name + String( "BoxGeometryTexCoordBuffer");
	bufferi.bufferSemantics = TEXCOORD_SEMANTICS;
	setAttributeBuffer(new Buffer(bufferi,false,0));

	setIndexBuffer(
		new Buffer(
			BufferInfo(
				name + String("BoxGeometryIndexBuffer"),
				ContextTypeFlags(HOST_CONTEXT_TYPE_FLAG | OPEN_GL_CONTEXT_TYPE_FLAG),
				INDEX_SEMANTICS,
				TYPE_UINT32,
				6 * 6, //6 faces * 2* triangles @ 3 verts
				BufferElementInfo(1,GPU_DATA_TYPE_UINT,32,false),
				VERTEX_INDEX_BUFFER_TYPE,
				NO_CONTEXT_TYPE
			)
		)
	);


	Vector4D* posBuffer = 	reinterpret_cast<Vector4D*>(getAttributeBuffer(POSITION_SEMANTICS)->getCPUBufferHandle());
	Vector4D* normalBuffer =reinterpret_cast<Vector4D*>(getAttributeBuffer(NORMAL_SEMANTICS)->getCPUBufferHandle());
	Vector4D* tangentBuffer = 0;
	if(addTangents)	{
		tangentBuffer = 	reinterpret_cast<Vector4D*>(getAttributeBuffer(TANGENT_SEMANTICS)->getCPUBufferHandle());
	}
	Vector4D* tcBuffer = 	reinterpret_cast<Vector4D*>(getAttributeBuffer(TEXCOORD_SEMANTICS)->getCPUBufferHandle());
	unsigned int* indexBuffer = reinterpret_cast<unsigned int*>(getIndexBuffer()->getCPUBufferHandle());



	//iterate over the six faces:
	for(int axis=0; axis<3; axis++)
	{
		for(int side = 1; side >= -1; side -= 2)
		{
			Vector3D normal = Vector3D(axis==0?side:0,axis==1?side:0, axis==2?side:0);
			Vector3D left = Vector3D(
					((axis==2) || (axis ==1))	 ? 	-side 	:	0,
					0,
					axis==0?side:0
			);

			Vector3D down= glm::cross(normal,left);

			Vector3D tangent = left * (-1.0f);

			int vertexIndexBase = 8* axis + 4*(1-(side+1)/2);
			int indexIndexBase = 12* axis + 6*(1-(side+1)/2);

			//lower left
			posBuffer[vertexIndexBase + 0] 		= Vector4D( (normal + left + down)* halfExtends, 1 );
			normalBuffer[vertexIndexBase + 0]	= Vector4D( normal, 0 );
			if(addTangents){
				tangentBuffer[vertexIndexBase+0]= Vector4D( tangent, 0 );
			}
			tcBuffer[vertexIndexBase + 0]		= Vector4D(0,0,0, 0 ) * texcoordScale;
			//lower right
			posBuffer[vertexIndexBase + 1] 		= Vector4D( (normal - left + down)* halfExtends , 1 );
			normalBuffer[vertexIndexBase + 1]	= Vector4D( normal, 0 );
			if(addTangents){
				tangentBuffer[vertexIndexBase+1]= Vector4D( tangent, 0 );
			}
			tcBuffer[vertexIndexBase + 1]		= Vector4D(1,0,0, 0 )* texcoordScale;
			//upper right
			posBuffer[vertexIndexBase + 2] 		= Vector4D( (normal - left - down)* halfExtends , 1 );
			normalBuffer[vertexIndexBase + 2]	= Vector4D( normal, 0 );
			if(addTangents){
				tangentBuffer[vertexIndexBase+2]= Vector4D( tangent, 0 );
			}
			tcBuffer[vertexIndexBase + 2]		= Vector4D(1,1,0, 0 )* texcoordScale;
			//upper left
			posBuffer[vertexIndexBase + 3] 		= Vector4D( (normal + left - down)* halfExtends , 1 );
			normalBuffer[vertexIndexBase + 3]	= Vector4D( normal, 0 );
			if(addTangents){
				tangentBuffer[vertexIndexBase+3]= Vector4D( tangent, 0 );
			}
			tcBuffer[vertexIndexBase + 3]		= Vector4D(0,1,0, 0 )* texcoordScale;

			indexBuffer[indexIndexBase + 0]=  vertexIndexBase + 0;
			indexBuffer[indexIndexBase + 1]=  vertexIndexBase + 1;
			indexBuffer[indexIndexBase + 2]=  vertexIndexBase + 2;
			indexBuffer[indexIndexBase + 3]=  vertexIndexBase + 0;
			indexBuffer[indexIndexBase + 4]=  vertexIndexBase + 2;
			indexBuffer[indexIndexBase + 5]=  vertexIndexBase + 3;

//			LOG<<DEBUG_LOG_LEVEL<<"VERTICES OF BOX, face "<<
//					((side>0)?"positive":"negative") <<
//					(	(axis==0)
//							?" X"
//							:( (axis==1)
//								?" Y"
//								:" Z"	)    )
//
//					<< ": \n";
//			for(int i=0;i<4;i++)
//			{
//				LOG<<DEBUG_LOG_LEVEL
//						<<"Index of vertex :"<<vertexIndexBase+i
//						<<"; Vertex coords: "<<posBuffer[vertexIndexBase + i]
//						<<"; Normal: "<<normalBuffer[vertexIndexBase + i]
//						<<"; start index for face in index buffer: "<<indexIndexBase<<";\n"
//		 	    ;
//			}

		}
	}

	getAttributeBuffer(POSITION_SEMANTICS)->copyFromHostToGPU();
	getAttributeBuffer(NORMAL_SEMANTICS)->copyFromHostToGPU();
	if(addTangents){getAttributeBuffer(TANGENT_SEMANTICS)->copyFromHostToGPU();}
	getAttributeBuffer(TEXCOORD_SEMANTICS)->copyFromHostToGPU();
	getIndexBuffer()->copyFromHostToGPU();

}
Example #7
0
File: Mesh.cpp Project: luk2010/GRE
void Mesh::setIndexBuffer(const HardwareIndexBuffer& indexbuffer)
{
    auto ptr = lock();
    if ( ptr )
        ptr->setIndexBuffer(indexbuffer);
}