Beispiel #1
0
void Init(void)
{
  //Check if Opengl version is at least 3.0
  const GLubyte* glVersion( glGetString(GL_VERSION) );
  int major = glVersion[0] - '0';
  int minor = glVersion[2] - '0';
  if( major < 3 || minor < 0 )
  {
    std::cerr<<"ERROR: Minimum OpenGL version required for this demo is 3.0. Your current version is "<<major<<"."<<minor<<std::endl;
    exit(-1);
  }
 
  //Init glew
  glewInit();
 
  //Set clear color
  glClearColor(1.0, 1.0, 1.0, 0.0);
 
  //Create and bind the shader program
  gProgram = CompileShaders( gVertexShaderSource, gFragmentShaderSource );
  glUseProgram(gProgram);
 
  glUniform1i(0,0); //Sampler refers to texture unit 0
  
  GenerateGeometry();
  GenerateArrayTexture();
}
Beispiel #2
0
int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowSize(1024, 768);
	glutInitWindowPosition(100, 100);
	glutCreateWindow("Week 3");

	InitializeGlutCallback();

	GLenum res = glewInit();
	if (res != GLEW_OK)
	{
		fprintf(stderr, "Error: %s\n", glewGetErrorString(res));
		return 1;
	}

	glClearColor(0.f, 0.f, 0.f, 0.f);

	CreateVertexBuffers();

	CompileShaders();

	glutMainLoop();
	return 0;
}
Beispiel #3
0
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Tutorial 13");

    InitializeGlutCallbacks();

    // Must be done after glut is initialized!
    GLenum res = glewInit();
    if (res != GLEW_OK) {
      fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
      return 1;
    }

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    CreateVertexBuffer();
    CreateIndexBuffer();

    CompileShaders();

    glutMainLoop();

    return 0;
}
Beispiel #4
0
int main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowSize(800, 600);
	glutInitWindowPosition(100, 100);
	glutCreateWindow("09 - Interpolation (OpenGL)");

	InitializeGlutCallbacks();

	// Must be done after glut is initialized!
	GLenum res = glewInit();
	if (res != GLEW_OK)
	{
		fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
		return 1;
	}

	printf("GL version: %s\n", glGetString(GL_VERSION));
	glClearColor(0.f, 0.f, 0.f, 0.f);

	CreateVertexBuffer();
	CompileShaders();

	glutMainLoop();
	return 0;
}
Beispiel #5
0
ComputeShader::ComputeShader( Device& _Device, const char* _pShaderFileName, ID3DBlob* _pCS )
	: Component( _Device )
	, m_pCS( NULL )
	, m_pShaderPath( NULL )
	, m_pIncludeOverride( NULL )
	, m_pMacros( NULL )
	, m_bHasErrors( false )
#if defined(_DEBUG) || !defined(GODCOMPLEX)
	, m_LastShaderModificationTime( 0 )
#endif
#ifdef COMPUTE_SHADER_COMPILE_THREADED
	, m_hCompileThread( 0 )
#endif
{

#if defined(_DEBUG) || !defined(GODCOMPLEX)
	m_pShaderFileName = CopyString( _pShaderFileName );
#endif
#ifndef GODCOMPLEX
	m_pShaderPath = GetShaderPath( _pShaderFileName );
	m_Pointer2FileName.Add( NULL, m_pShaderPath );
#endif

	ASSERT( _pCS != NULL, "You can't provide a NULL CS blob!" );

	CompileShaders( NULL, _pCS );
}
Beispiel #6
0
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Homework 3: camera");
    glutGameModeString("1280x1024@32");
    glutEnterGameMode();

    InitializeGlutCallbacks();

    pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT);

    GLenum res = glewInit();
    if (res != GLEW_OK) {
      fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
      return 1;
    }

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    CreateVertexBuffer();
    CreateIndexBuffer();

    CompileShaders();

    glutMainLoop();

    return 0;
}
Beispiel #7
0
int main(int argc, char **argv) 
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowPosition(200, 200);
  glutInitWindowSize(1024, 768);
  glutCreateWindow("Tutorial 06");

  InitializeGlutCallBacks();

  GLenum res = glewInit();
  if (res != GLEW_OK) {
    fprintf(stderr, "Error : '%s\n", glewGetErrorString(res));
    return 1;
  }

  printf("GL version : %s\n", glGetString(GL_VERSION));
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  CreateVertexBuffer();

  CompileShaders();

  glutMainLoop();
  return 0;
}
Beispiel #8
0
void glut_initialization () {
	glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
	glutInitWindowSize(D_W * 4, D_H * 4);
	glutInitWindowPosition(D_X_INIT, D_Y_INIT);
    glutCreateWindow("Tutorial 06");
	if (g_fullscreen) {
	//glutGameModeString("640x480:32@1000");
		glutGameModeString ("1280x960:32@60");
	//glutGameModeString("1920x1080:32@1000");
		glutEnterGameMode ();
	}

    InitializeGlutCallbacks();

	
    // Must be done after glut is initialized!
    GLenum res = glewInit();
    if (res != GLEW_OK) {
      fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
      exit (1);
    }

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    CompileShaders();

	glUniform1i(gSampler, 0);

	core.init ();

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
Beispiel #9
0
bool TextureCache::Initialize()
{
	m_texture_upload_buffer =
		StreamBuffer::Create(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, INITIAL_TEXTURE_UPLOAD_BUFFER_SIZE,
			MAXIMUM_TEXTURE_UPLOAD_BUFFER_SIZE);
	if (!m_texture_upload_buffer)
	{
		PanicAlert("Failed to create texture upload buffer");
		return false;
	}

	if (!CreateRenderPasses())
	{
		PanicAlert("Failed to create copy render pass");
		return false;
	}

	m_texture_converter = std::make_unique<TextureConverter>();
	if (!m_texture_converter->Initialize())
	{
		PanicAlert("Failed to initialize texture converter.");
		return false;
	}

	if (!CompileShaders())
	{
		PanicAlert("Failed to compile one or more shaders");
		return false;
	}

	return true;
}
Beispiel #10
0
void App::ScanInput( float dt )
{
	if(GetFocus() == mainWnd)
	{
		// update shaders if necessary
		if(GetAsyncKeyState(VK_F1) & 0x8000)
			CompileShaders();

		// Camera movement
		if (GetAsyncKeyState('W') & 0x8000)
			viewports[0].Walk(10.f * dt);
		if (GetAsyncKeyState('S') & 0x8000)
			viewports[0].Walk(-10.f * dt);
		if (GetAsyncKeyState('A') & 0x8000)
			viewports[0].Strafe(-10.f * dt);
		if (GetAsyncKeyState('D') & 0x8000)
			viewports[0].Strafe(10.f * dt);
		if(GetAsyncKeyState('Y') & 0x8000)
			shaderParams->lacunarity += 0.01f;
		if(GetAsyncKeyState('H') & 0x8000)
			shaderParams->lacunarity -= 0.01f;
		if(GetAsyncKeyState('U') & 0x8000)
			shaderParams->gain += 0.005f;
		if(GetAsyncKeyState('J') & 0x8000)
			shaderParams->gain -= 0.005f;
		if(GetAsyncKeyState('I') & 0x8000)
			shaderParams->gradOffset += 0.01f;
		if(GetAsyncKeyState('K') & 0x8000)
			shaderParams->gradOffset -=0.01f;
		if(GetAsyncKeyState('O') & 0x8000)
			shaderParams->gradScale += 0.01f;
		if(GetAsyncKeyState('L') & 0x8000)
			shaderParams->gradScale -=0.01f;
	}
}
Beispiel #11
0
// Initialize application window
// Most of the error checking omitted
bool App::Init()
{
	/*
	viewports[0].SetVPSize(winWidth/2, winHeight/2);
	Viewport vp(viewports[0]);
	vp.SetVPPosition(winWidth/2, winHeight/2);
	viewports.push_back(vp);
	*/

	if(!InitWindow())
		return false;

	if(!InitD3D())
		return false;

	// Call resize to do rest of window initialization
	Resize();

	if(!CompileShaders())
		return false;

	// Set up sampler states for perlin noise
	SetupSamplers();

	// Set up lookup textures for perlin noise
	SetupTextures();	

	// Initialize vertex buffer with canvas quad
	InitCanvas();

	// Init default viewport
	viewports[0].RefreshBuffer();

	// Initialize viewport buffer
	D3D11_SUBRESOURCE_DATA vpbufData;
	vpbufData.pSysMem			= viewports[0].GetBufferData();
	vpbufData.SysMemPitch		= NULL;
	vpbufData.SysMemSlicePitch	= NULL;
	HR(dev->CreateBuffer(&Viewport::viewportBufferDesc, NULL, &viewportBuffer));

	// Initialize shader params buffer;
	D3D11_BUFFER_DESC shaderBufferDesc= {
		sizeof(ShaderParams),
		D3D11_USAGE_DYNAMIC,
		D3D11_BIND_CONSTANT_BUFFER,
		D3D11_CPU_ACCESS_WRITE,
		0
	};
	D3D11_SUBRESOURCE_DATA shaderBuffer;
	shaderBuffer.pSysMem			= shaderParams;
	shaderBuffer.SysMemPitch		= NULL;
	shaderBuffer.SysMemSlicePitch	= NULL;
	HR(dev->CreateBuffer(&shaderBufferDesc, &shaderBuffer, &shaderParamsBuffer));

	// And finally update the window
	UpdateWindow(mainWnd);

	return true;
}
Beispiel #12
0
bool Shader::Reload(ID3D11Device* device)
{
	Shader copy(this->mDescriptor);
	copy.mID = this->mID;
	ReleaseResources();
	this->mID = copy.mID;
	return CompileShaders(device, copy.mDescriptor);
}
Beispiel #13
0
TextureCache::TextureCache()
{
	CompileShaders();

	s_ActiveTexture = -1;
	for (auto& gtex : s_Textures)
		gtex = -1;
}
Beispiel #14
0
Shader::Shader(const char* vertexFile, const char* fragmentFile) {
	string vertexCode = FileUtils::GetFileContents(vertexFile);
	string fragmentCode = FileUtils::GetFileContents(fragmentFile);
	const char* vertexSource = vertexCode.c_str();
	const char* fragmentSource = fragmentCode.c_str();

	CompileShaders(vertexSource, fragmentSource);
}
Beispiel #15
0
bool PickingShader::Compile()
{
    if (CompileShaders(PickingVertexShader, NULL,
            PickingFragmentShader) == false) {
        PrintShaderWarning("Compiling shaders failed.");
        return false;
    }
    vertex_position_ = glGetAttribLocation(program_, "vertex_position");
    vertex_index_ = glGetAttribLocation(program_, "vertex_index");
    MVP_ = glGetUniformLocation(program_, "MVP");
    return true;
}
int main(int argc, char** argv)
{
//    Magick::InitializeMagick(*argv);    
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Tutorial 16");
    glutGameModeString("1280x1024@32");
  //  glutEnterGameMode();

    InitializeGlutCallbacks();

    pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT);

    // Must be done after glut is initialized!
    GLenum res = glewInit();
    if (res != GLEW_OK) {
      fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
      return 1;
    }

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glFrontFace(GL_CW);
    glCullFace(GL_BACK);
    glEnable(GL_CULL_FACE);

    CreateVertexBuffer();
    CreateIndexBuffer();

    CompileShaders();

    glUniform1i(gSampler, 0);

    pTexture = new Texture(GL_TEXTURE_2D, "../Content/test.png");

    if (!pTexture->Load()) {
        return 1;
    }
 
    gPersProjInfo.FOV = 60.0f;
    gPersProjInfo.Height = WINDOW_HEIGHT;
    gPersProjInfo.Width = WINDOW_WIDTH;
    gPersProjInfo.zNear = 1.0f;
    gPersProjInfo.zFar = 100.0f;                

    glutMainLoop();

    return 0;
}
void Renderer::Init( LPDIRECT3DDEVICE9 pD3DDevice, int iXPos, int iYPos, int iWidth, int iHeight, float fPixelRatio )
{
	DebugConsole::Log("Renderer: Viewport x%d, y%d, w%d, h%d, pixel%f\n", iXPos, iYPos, iWidth, iHeight, fPixelRatio );
	m_pD3DDevice = pD3DDevice;
	g_viewport.X = iXPos;
	g_viewport.Y = iYPos;
	g_viewport.Width = iWidth;
	g_viewport.Height = iHeight;
	g_viewport.MinZ = 0;
	g_viewport.MaxZ = 1;

	g_defaultAspect = ((float)iWidth / iHeight) * fPixelRatio;

	m_pD3DDevice->CreateDepthStencilSurface(1024, 1024, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &g_depthBuffer, NULL);
/*
	if (D3D_OK != m_pD3DDevice->GetDepthStencilSurface(&g_oldDepthBuffer))
	{
		DebugConsole::Log("Renderer: No default depth buffer\n", iXPos, iYPos, iWidth, iHeight, fPixelRatio );
		//OutputDebugString("Vortex INFO: Renderer::Init - Failed to Get old depth stencil\n");
		// Create our own
// 		D3DSURFACE_DESC desc;
// 		g_backBuffer->GetDesc(&desc);
// 		g_device->CreateDepthStencilSurface(desc.Width, desc.Height, D3DFMT_LIN_D24S8, 0, &g_oldDepthBuffer);
// 		g_ownDepth = true;
	}
	else
	{
//		g_ownDepth = false;
	}
*/
	{
		char fullname[512];
		sprintf_s(fullname, 512, "%sfont.bmp", g_TexturePath );
		m_pTextureFont = LoadTexture( fullname, false );
	}

	D3DXCreateMatrixStack(0, &g_matrixStack);
	g_matrixStackLevel = 0;

	g_scratchTexture = CreateTexture( 512, 512 );

	CompileShaders();

	CreateCubeBuffers();

	CreateFonts();
}
Beispiel #18
0
void		ComputeShader::RebuildShader()
{
	DWORD	ErrorCode = WaitForSingleObject( m_hCompileMutex, 30000 );
#ifdef _DEBUG
	ASSERT( ErrorCode == WAIT_OBJECT_0, "Failed shader rebuild after 30 seconds waiting for access !" );
#else
	if ( ErrorCode != WAIT_OBJECT_0 )
		ExitProcess( -1 );	// Failed !
#endif
#endif
 
	// Reload file
	FILE*	pFile = NULL;
	fopen_s( &pFile, m_pShaderFileName, "rb" );
//	ASSERT( pFile != NULL, "Failed to open shader file !" );
	if ( pFile == NULL )
	{	// Failed! Unlock but don't update time stamp so we try again next time...
		Unlock();
		return;
	}

	fseek( pFile, 0, SEEK_END );
	size_t	FileSize = ftell( pFile );
	fseek( pFile, 0, SEEK_SET );

	char*	pShaderCode = new char[FileSize+1];
	fread_s( pShaderCode, FileSize, 1, FileSize, pFile );
	pShaderCode[FileSize] = '\0';

	fclose( pFile );

	// Compile
	CompileShaders( pShaderCode );

	delete[] pShaderCode;

	// Release the mutex: it's now safe to access the shader !
	Unlock();

#ifdef COMPUTE_SHADER_COMPILE_THREADED
	// Close the thread once we're done !
	if ( m_hCompileThread )
		CloseHandle( m_hCompileThread );
	m_hCompileThread = 0;
#endif
}
Beispiel #19
0
TextureShader::TextureShader(ID3D11Device *device, ID3D11DeviceContext *context)
{
	if (!CompileShaders()) {
		DebugOut("TextureShader::CompileShaders failed!\n");
		return;
	}

	if (!CreateShaders(device)) {
		DebugOut("TextureShader::CreateShaders failed!\n");
		return;
	}

	if (!MakeBuffers(device, context)) {
		DebugOut("TextureShader::MakeBuffers failed!\n");
		return;
	}
};
Beispiel #20
0
void init()
{
	// Create 3 vertices that make up a triangle that fits on the viewport 
	GLfloat vertices[] = {-1.0f, -1.0f, 0.0f, 1.0,
		1.0f, -1.0f, 0.0f, 1.0, 
		0.0f, 1.0f, 0.0f, 1.0};
	// Create a color array that identfies the colors of each vertex (format R, G, B, A)
	GLfloat colors[] = {0.0f, 1.0f, 0.0f, 1.0f,
		1.0f, 0.0f, 0.0f, 1.0f,
		0.0f, 0.0f, 1.0f, 1.0f};
	// Set up the shaders
	player_init();
	GLuint shaderProgramID = CompileShaders();
	// load teapot mesh into a vertex buffer array
	generateObjectBufferTeapot ();
	computeMatricesFromInputs();
	glutSetCursor(GLUT_CURSOR_NONE);
	//	glutWarpPointer(1024/2, 768/2);
}
Beispiel #21
0
 BloomEffect::BloomEffect(const uint32 Tex1, const uint32 Width, const uint32 Height) : IEffect(Width, Height)
 {   
     
     // Set RTT
     UseRTT(Tex1);
     
     // Create Fragment Shader
     FragmentShaderString =      "const float BloomSize = 1.0/2048.0;"
                                 "uniform sampler2D uTex0;"
                                 "varying vec2 vTexcoord;"        
                                 "void main()"
                                 "{"
                                 "vec4 sum = vec4(0);"
                                 "vec2 texcoord = vTexcoord;"
                                 "int j;"
                                 "int i;"
                                 "for( i= -4 ;i < 4; i++)"
                                 "{"
                                         "for (j = -3; j < 3; j++)"
                                         "{"
                                             "sum += texture2D(uTex0, texcoord + vec2(j, i)*0.004) * 0.25;"
                                         "}"
                                 "}"
                                 "if (texture2D(uTex0, texcoord).r < 0.3)"
                                 "{"
                                 "gl_FragColor = sum*sum*0.012 + texture2D(uTex0, texcoord);"
                                 "}"
                                 "else"
                                 "{"
                                     "if (texture2D(uTex0, texcoord).r < 0.5)"
                                     "{"
                                         "gl_FragColor = sum*sum*0.009 + texture2D(uTex0, texcoord);"
                                     "}"
                                     "else"
                                     "{"
                                         "gl_FragColor = sum*sum*0.0075 + texture2D(uTex0, texcoord);"
                                     "}"
                                 "}"
                             "}";
     
     CompileShaders();
 }
Beispiel #22
0
void MyView::ResetConsole()
{
	system("cls");
	//Application instructions
	std::cout << "ABOUT" << std::endl;
	std::cout << "Spice My Sponza - 3D Graphics Programming ICA1" << std::endl;
	std::cout << "P4011584 - Frederic Babord 2015 - 2016" << std::endl << std::endl;
	std::cout << "Submission date: 04th February 2016" << std::endl << std::endl;
	std::cout << "INSTRUCTIONS" << std::endl;
	std::cout << "Press F1 to enable camera animation." << std::endl;
	std::cout << "Press F2 to view the direction of the vertex normals." << std::endl;
	std::cout << "Press F3 to enable wireframe mode." << std::endl;
	std::cout << "Press F4 to change rendering mode (Fill, Line, Point)." << std::endl;
	std::cout << "Press F5 to recompile the shader." << std::endl << std::endl;
	std::cout << "Press Q to reduce the normal line length." << std::endl;
	std::cout << "Press E to increase the normal line length." << std::endl;
	std::cout << "Press Z to reduce the specular intensity smudge factor." << std::endl;
	std::cout << "Press C to increase the specular intensity smudge factor." << std::endl << std::endl;
	std::cout << "Press Esc to Close." << std::endl << std::endl;
	CompileShaders();
}
Beispiel #23
0
int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
	glutInitWindowPosition(200, 200);
	glutCreateWindow("Tutorial 15 - Camera Control Part2");
// 	glutGameModeString("1920*1200@32");
// 	glutEnterGameMode();

	InitializeGlutCallbacks();

	pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT);

	// Must be done after glut is initialized!
	GLenum res = glewInit();
	if (res != GLEW_OK)
	{
		fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
		return 1;
	}

	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

	CreateVertexBuffer();
	CreateIndexBuffer();

	CompileShaders();

	gPersProjInfo.FOV = 60.0f;
	gPersProjInfo.Height = WINDOW_HEIGHT;
	gPersProjInfo.Width = WINDOW_WIDTH;
	gPersProjInfo.zNear = 1.0f;
	gPersProjInfo.zFar = 100.0f;

	glutMainLoop();

	return 1;
}
Beispiel #24
0
// Only used by Headless! TODO: Remove
void DirectxInit(HWND window) {
	pD3D = Direct3DCreate9( D3D_SDK_VERSION );

	// Set up the structure used to create the D3DDevice. Most parameters are
	// zeroed out. We set Windowed to TRUE, since we want to do D3D in a
	// window, and then set the SwapEffect to "discard", which is the most
	// efficient method of presenting the back buffer to the display.  And 
	// we request a back buffer format that matches the current desktop display 
	// format.
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	// TODO?
	d3dpp.Windowed = TRUE;
	d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
	d3dpp.MultiSampleQuality = 0;
	d3dpp.BackBufferCount = 1;
	d3dpp.EnableAutoDepthStencil = TRUE;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
	//d3dpp.PresentationInterval = (useVsync == true)?D3DPRESENT_INTERVAL_ONE:D3DPRESENT_INTERVAL_IMMEDIATE;
	//d3dpp.RingBufferParameters = d3dr;

	HRESULT hr = pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
                                      D3DCREATE_HARDWARE_VERTEXPROCESSING,
                                      &d3dpp, &pD3Ddevice);
	if (hr != D3D_OK) {
		// TODO
	}

#ifdef _XBOX
	pD3Ddevice->SetRingBufferParameters( &d3dr );
#endif

	std::string errorMessage;
	CompileShaders(errorMessage);

	fbo_init(pD3D);
}
Beispiel #25
0
int main(int args, char **argv)
{
	glutInit(&args, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutInitWindowPosition(0,0);
	glutInitWindowSize(1024, 600);
	glutCreateWindow("tutorial 8");

	InitializeGlutCallBacks();

	GLenum res = glewInit();
	if (res != GLEW_OK)
	{
		fprintf(stderr, "glew init error \n");
		return 1;
	}
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	CreateVertexBuffer();
	CompileShaders();
	glutMainLoop();
	system("pause");
	return 0;
}
Beispiel #26
0
void FShaderManager::Recompile()
{
	Clean();
	CompileShaders();
}
Beispiel #27
0
// Construct visual object display list.
void Sphere::initialize()
{
	CompileShaders();

	// vector containers to hold  data
	// vertice positions
	vector<vec3> v;

	vector<vec3> n;

	GLuint VBO, NBO, IBO;

	// Vector contains indexes to the data
	vector<unsigned int> indices;

	// Declare the variables we are going to use
	float X1,Y1,X2,Y2,Z1,Z2;
	float inc1,inc2,inc3,inc4, Radius1, Radius2;

	for(int w = 0; w < Resolution; w++) {
		
		for(int h = (-Resolution/2); h < (Resolution/2); h++){

			inc1 = (w/(float)Resolution) * 2 * PI;
			inc2 = ((w+1)/(float)Resolution) * 2 * PI;
 
			inc3 = (h/(float)Resolution) * PI;
			inc4 = ((h+1)/(float)Resolution) * PI;

			X1 = sin(inc1);
			Y1 = cos(inc1);
			X2 = sin(inc2);
			Y2 = cos(inc2);

			// store the upper and lower radius, remember everything is going to be drawn as triangles
			Radius1 = Radius*cos(inc3);
			Radius2 = Radius*cos(inc4);

			Z1 = Radius*sin(inc3); 
			Z2 = Radius*sin(inc4);

			// insert the triangle coordinates
			v.push_back( vec3( Radius1*X1, Z1, Radius1*Y1));
			v.push_back( vec3( Radius1*X2, Z1, Radius1*Y2));
			v.push_back( vec3( Radius2*X2, Z2, Radius2*Y2));

			v.push_back( vec3( Radius1*X1, Z1, Radius1*Y1));
			v.push_back( vec3( Radius2*X2, Z2, Radius2*Y2));
			v.push_back( vec3( Radius2*X1, Z2, Radius2*Y1));
			
			n.push_back( vec3(X1,Z1,Y1) / length( vec3(X1,Z1,Y1) ));
			n.push_back( vec3(X2,Z1,Y2) / length( vec3(X2,Z1,Y2) ));
			n.push_back( vec3(X2,Z2,Y2) / length( vec3(X2,Z2,Y2) ));

			n.push_back( vec3(X1,Z1,Y1) / length( vec3(X1,Z1,Y1) ));
			n.push_back( vec3(X2,Z2,Y2) / length( vec3(X2,Z2,Y2) ));
			n.push_back( vec3(X1,Z2,Y1) / length( vec3(X1,Z2,Y1) ));
		}
	}

	for ( unsigned int i=0; i < v.size(); i++ ) {

		indices.push_back( i );
	}

	glGenVertexArrays (1, &vertexArrayObject);
	glBindVertexArray( vertexArrayObject );

	// finally, create the buffers and bind the data to them
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO); // Buffer for vertex data
	glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(vec3), &v[0], GL_STATIC_DRAW); //Buffering vertex data
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(0);
	
	glGenBuffers(1, &NBO);
	glBindBuffer(GL_ARRAY_BUFFER, NBO);
	glBufferData(GL_ARRAY_BUFFER, n.size() * sizeof(vec3), &n[0], GL_STATIC_DRAW);
	glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(1);

	// Generate a buffer for the indices as well 
	glGenBuffers(1, &IBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0] , GL_STATIC_DRAW);

	// store the number of indices for later use
	numberOfIndices = indices.size();
 
	v.clear();
	n.clear();
	indices.clear();

	VisualObject::initialize();

} // end initialize
Beispiel #28
0
int C_DECL main(int argc, char* argv[])
{
    ProcessArguments(argc, argv);

    if (Options & EOptionDumpConfig) {
        printf("%s", DefaultConfig);
        if (Worklist.empty())
            return ESuccess;
    }

    if (Options & EOptionDumpVersions) {
        printf("Glslang Version: %s %s\n", GLSLANG_REVISION, GLSLANG_DATE);
        printf("ESSL Version: %s\n", glslang::GetEsslVersionString());
        printf("GLSL Version: %s\n", glslang::GetGlslVersionString());
        std::string spirvVersion;
        glslang::GetSpirvVersion(spirvVersion);
        printf("SPIR-V Version %s\n", spirvVersion.c_str());
        printf("GLSL.std.450 Version %d, Revision %d\n", GLSLstd450Version, GLSLstd450Revision);
        if (Worklist.empty())
            return ESuccess;
    }

    if (Worklist.empty()) {
        usage();
    }

    ProcessConfigFile();

    //
    // Two modes:
    // 1) linking all arguments together, single-threaded, new C++ interface
    // 2) independent arguments, can be tackled by multiple asynchronous threads, for testing thread safety, using the old handle interface
    //
    if (Options & EOptionLinkProgram ||
        Options & EOptionOutputPreprocessed) {
        glslang::InitializeProcess();
        CompileAndLinkShaders();
        glslang::FinalizeProcess();
    } else {
        ShInitialize();

        bool printShaderNames = Worklist.size() > 1;

        if (Options & EOptionMultiThreaded) {
            const int NumThreads = 16;
            void* threads[NumThreads];
            for (int t = 0; t < NumThreads; ++t) {
                threads[t] = glslang::OS_CreateThread(&CompileShaders);
                if (! threads[t]) {
                    printf("Failed to create thread\n");
                    return EFailThreadCreate;
                }
            }
            glslang::OS_WaitForAllThreads(threads, NumThreads);
        } else
            CompileShaders(0);

        // Print out all the resulting infologs
        for (int w = 0; w < NumWorkItems; ++w) {
            if (Work[w]) {
                if (printShaderNames)
                    PutsIfNonEmpty(Work[w]->name.c_str());
                PutsIfNonEmpty(Work[w]->results.c_str());
                delete Work[w];
            }
        }

        ShFinalize();
    }

    if (CompileFailed)
        return EFailCompile;
    if (LinkFailed)
        return EFailLink;

    return 0;
}
int main(int argc,char * argv[])
{
	// Initialize GLUT
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
	glutInitWindowSize(500, 400);
	// Center window
	glutInitWindowPosition(
		glutGet(GLUT_SCREEN_WIDTH)/2-glutGet(GLUT_INIT_WINDOW_WIDTH)/2,
		glutGet(GLUT_SCREEN_HEIGHT)/2-glutGet(GLUT_INIT_WINDOW_HEIGHT)/2);
	glutCreateWindow("Texture Example");
	glutCreateMenu(NULL);
		
    // Set GLUT callbacks
	glutDisplayFunc(DisplayCB);
	//glutCloseFunc(closeEvent);
    //glutReshapeFunc(resizeEvent);
    //glutMotionFunc(mouseEvent);
    //glutMouseFunc(mouseButtonEvent);
    //glutPassiveMotionFunc(mousePassiveEvent);
    //glutKeyboardFunc(keyboardEvent);
    //glutSpecialFunc(keySpecEvent);
	
	// Must be done after glut is initialized!
	GLenum res = glewInit();
	if (res != GLEW_OK) {
		fprintf( stderr, "Error: ''.\n", glewGetErrorString(res));
		return 1;
	} 

	printf("GL version: %s.\n", glGetString(GL_VERSION) );

	glClearColor(0.0f, .3f, 0.0f, 1.0f); 

	// create vertex array object
	GLuint iVAO;
	glGenVertexArrays(1, &iVAO);
	glBindVertexArray(iVAO);

	// create a vertex buffer object and copy the vertex data to it
	GLfloat vertices[] = {
		// pos, color, texcoord
		-0.5, -0.5, 0,	1.0f, 0.0f, 0.0f,	0.0f, 0.0f, // top-left
		 0.5, -0.5, 0,	0.0f, 1.0f, 0.0f,	1.0f, 0.0f, // top-left
		 0.5,  0.5, 0,	1.0f, 0.0f, 1.0f,	1.0f, 1.0f, // top-left
		-0.5,  0.5, 0,	1.0f, 1.0f, 1.0f,	0.0f, 1.0f, // top-left	
	}; 
	glGenBuffers(1, &g_iVBO);
	glBindBuffer(GL_ARRAY_BUFFER, g_iVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	unsigned int indices[] = { 0, 1, 2, 
		0, 2, 3 };
	glGenBuffers(1, &g_iEBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_iEBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 

	CompileShaders(); 

	// Load textures
    GLuint texId;
    glGenTextures(1, &texId);

    glActiveTexture(GL_TEXTURE0); // for one tex this can be ignore, it is designed for multiply texture.
    glBindTexture(GL_TEXTURE_2D, texId);
    
	// Black/white checkerboard
	float pixels[] = {
		0.0f, 0.0f, 0.0f,   1.0f, 1.0f, 1.0f,
		1.0f, 1.0f, 1.0f,   0.0f, 0.0f, 0.0f
	};
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_FLOAT, pixels);
	
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);GL_LINEAR;
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);GL_LINEAR;
	
	// Call the GLUT main loop
	glutMainLoop();

	glDeleteTextures(1, &texId);
    glDeleteProgram(g_iShaderProgram);
    glDeleteBuffers(1, &g_iVBO);
    glDeleteVertexArrays(1, &iVAO);
	return 0;
}
Beispiel #30
0
FShaderManager::FShaderManager()
{
	CompileShaders();
}