code stringlengths 1 2.06M | language stringclasses 1
value |
|---|---|
#include "AABB.hpp"
#include "Quaternion.hpp"
#include "Renderer/VBO.hpp"
namespace engine {
AABB::AABB(Vector3F pOrigin, Vector3F pEnd) : mOrigin(pOrigin), mEnd(pEnd){
}
void AABB::Init(Vector3F* pVertices, u32 pSize){
for(u32 i = 0; i < pSize; ++i){
mOrigin.x = Math::Min(pVertices[i].x, mOrigin.x);
mOrig... | C++ |
inline engine::Quaternion::Quaternion(f32 X, f32 Y, f32 Z, f32 W) : x(X), y(Y), z(Z), w(W){
}
inline engine::Quaternion::Quaternion(const Matrix4 &mat){
FromMatrix(mat);
}
inline engine::Quaternion::Quaternion(const Vector3F &Axis, f32 Angle){
FromAxisAngle(Axis, Angle);
}
inline Quaternion engine::Quat... | C++ |
#ifndef QUATERNION_HPP
#define QUATERNION_HPP
#include "Mathlib.hpp"
#include "Matrix4.hpp"
namespace engine {
class Quaternion{
public:
/// \brief Ctor from 4 floats
Quaternion(f32 X = 0, f32 Y = 0, f32 Z = 0, f32 W = 0);
/// \brief Ctor from matrix
Quaternion(const Matrix4 &mat);
/// \b... | C++ |
#ifndef VECTOR3_HPP
#define VECTOR3_HPP
#include "Mathlib.hpp"
namespace engine {
class Matrix4;
template<class T>
class Vector3{
public:
Vector3(T x = 0, T y = 0, T z =0);
// Sets vector components
void Set(T x, T y, T z);
// Returns the vector components in an array
void XYZ... | C++ |
#include "Image.hpp"
#include "Core/ResourceManager.hpp"
#include "Debug/Debug.hpp"
namespace engine {
Image::Image(const Vector2I &pSize) : mSize(pSize), mBPP(GL_RGBA8), mFormat(GL_RGBA){
}
Image::Image(const std::string &pName, const Vector2I &pSize, sf::Image &pSurface) :
mSize(pSize),
mBPP(... | C++ |
#include "Camera.hpp"
#include "Renderer/Renderer.hpp"
namespace engine{
Camera::Camera() : mName("Camera1"), mPosition(Vector3F::ZERO) {
Init();
}
Camera::Camera(const Vector3F &Pos) : mPosition(Pos) {
Init();
}
Camera::~Camera(){
}
void Camera::Init(){
mSpeed = 10.f;
mSensivity = ... | C++ |
#ifndef CAMERA_HPP
#define CAMERA_HPP
#include "Frustum.hpp"
#include "Utils/Shared.hpp"
#include "Math/Quaternion.hpp"
namespace engine {
class Renderer;
enum eCamDir{
CD_Forward,
CD_Right,
CD_Up
};
enum eCamRot{
CR_Pitch,
CR_Roll,
CR_Yaw
};
/// \brief Camera Class, Freefl... | C++ |
#include "Frustum.hpp"
#include "Utils/String.hpp"
#include "Debug/Debug.hpp"
namespace engine {
void Plane::Normalize(){
static f32 length = 0;
length = 1.f / Math::Sqrt(A * A + B * B + C * C);
A *= length;
B *= length;
C *= length;
D *= length;
}
const Plane& Frustum::operator()(s32 pIndex) const{
... | C++ |
#ifndef FRUSTUM_HPP
#define FRUSTUM_HPP
#include "Math/AABB.hpp"
#include "Math/Matrix4.hpp"
namespace engine {
/// \brief 3D Plane
class Plane{
public:
/// \brief Normalize the plane components
void Normalize();
/// \brief Returns the plane normal
Vector3F GetNormal() const { return Vector3F(A,B,C); }
... | C++ |
#include "ResourceManager.hpp"
#include "Utils/File.hpp"
#include "Utils/String.hpp"
#include "Debug/Debug.hpp"
namespace engine {
ResourceManager::ResourceManager(){
}
ResourceManager::~ResourceManager(){
if(!(mResources.empty())){
OmniLog << "Resources haven't been freed :" << eol << eol;
f... | C++ |
#include "Settings.hpp"
#include "Utils/String.hpp"
#include "Debug/Debug.hpp"
namespace engine{
Settings::Settings(){
}
bool Settings::Parse(){
bool ret = true;
mSettingsFile.Open(settingsFileName, RWM_ReadOnly, FP_Top);
if(mSettingsFile.IsOpened()){
std::string ... | C++ |
#ifndef RESOURCEMANAGER_HPP
#define RESOURCEMANAGER_HPP
#include <map>
#include <string>
#include "Resource.hpp"
#include "Utils/Singleton.hpp"
namespace engine {
/// \brief Singleton, Keep trace of all IResource inherited instances
class OOXAPI ResourceManager : public Singleton<ResourceManager> {
fri... | C++ |
#ifndef IMAGE_HPP
#define IMAGE_HPP
#include <vector>
#include "Core/Resource.hpp"
#include "Math/Vector2.hpp"
#include "Utils/SPointer.hpp"
namespace engine {
//// \brief Wrapper Class between an SFML Image and the engine
class OOXAPI Image : public IResource{
public:
/// \brief Ctor with empty image
Image(co... | C++ |
#ifndef WINDOW_HPP
#define WINDOW_HPP
#include "Utils/Shared.hpp"
namespace engine{
class OOXAPI Window{
public:
Window();
~Window();
/// \brief Return a pointer on the sf::Window
sf::RenderWindow* GetWindowPtr() { return &mWindow; }
/// \brief Return the reference of the sf::Window
sf::RenderWindo... | C++ |
#include "Input.hpp"
#include "Window.hpp"
#include "Debug/Debug.hpp"
namespace engine{
Input::Input() : mInputs(0), mWheelPos(0){
}
void Input::Init(Window &pWindow){
mWindow = &pWindow;
mInputs = &mWindow->GetWindow().GetInput();
}
bool Input::GetEvent(){
return mWindow->GetWindow().GetEvent(mEvents); ... | C++ |
#ifndef RENDERENUMS_HPP
#define RENDERENUMS_HPP
#include "Utils/Shared.hpp"
namespace engine {
/// \brief OpenGL Primitive Types
enum PrimitiveType {
PT_TRIANGLELIST,
PT_TRIANGLESTRIP,
PT_TRIANGLEFAN,
PT_LINELIST,
PT_LINESTRIP,
PT_POINTLIST
... | C++ |
#ifndef SETTINGS_HPP
#define SETTINGS_HPP
#include <vector>
#include <string>
#include "Math/Vector2.hpp"
#include "Math/Vector3.hpp"
#include "Utils/Color.hpp"
#include "Utils/File.hpp"
#include "Utils/Singleton.hpp"
namespace engine{
/// \brief Default config file
const char settingsFileName[] = "... | C++ |
#ifndef INPUT_HPP
#define INPUT_HPP
#include "Math/Vector2.hpp"
#include "Utils/Keys.hpp"
namespace engine{
class Window;
/// \brief Input Type, Mouse or Keyboard only
enum InputType{
IT_Mouse,
IT_Keyboard
};
/// \brief Structure used to store binding possibilities
struct InputBind{
InputType mInputType... | C++ |
#ifndef RESOURCE_HPP
#define RESOURCE_HPP
#include <string>
#include "Utils/Shared.hpp"
namespace engine {
/// \brief Interface for any resource type
class OOXAPI IResource{
public:
IResource();
/// \brief Can't instantiate class
virtual ~IResource() = 0;
/// \brief Returns the resource na... | C++ |
#ifndef ENTITY_HPP
#define ENTITY_HPP
#include "Renderer/VAO.hpp"
#include "Math/AABB.hpp"
#include "Math/Matrix4.hpp"
#include "Utils/Color.hpp"
#include "Debug/Exceptions.hpp"
namespace engine {
/// \brief Different types of entities (look below for desc)
enum eEntityType{
ET_NONE,
ET_OBJECT,
ET_MESH,
ET_... | C++ |
#include "Resource.hpp"
#include "ResourceManager.hpp"
#include "Debug/New.hpp"
namespace engine {
IResource::IResource() : mName(""), mRefCount(1){
}
IResource::~IResource(){
ResourceManager::Call().Remove(mName);
}
const std::string &IResource::GetName() const{
return mName;
}
void IRes... | C++ |
#include "Window.hpp"
#include "Settings.hpp"
#include "Utils/String.hpp"
#include "Debug/Debug.hpp"
namespace engine {
Window::Window() : mWidth(0), mHeight(0), mIsOpened(true){
// Récupération des Settings
mWidth = Settings::Call().GetSettingInt("WindowWidth");
if(!mWidth){
// Erreur, les settings n'ont... | C++ |
#include "Entity.hpp"
#include "ResourceManager.hpp"
#include "Math/Quaternion.hpp"
#include "Utils/String.hpp"
#include "Renderer/Renderer.hpp"
#include "Renderer/Shader.hpp"
#include "Debug/Debug.hpp"
namespace engine {
u32 Entity::EntityIDs = 0;
Entity::Entity() : mID(EntityIDs++), mType(ET_NONE), mUseTexture(f... | C++ |
////////////////////////////////////////////////////////////
/// \mainpage
///
/// \section welcome 00xEngine Index Page
/// Welcome to the official 00xEngine documentation.
/// Some links :
/// - Description of all 00xEngine <a href="./annotated.htm">classes</a>.
/// - Description of all 00xEngine <a href="./f... | C++ |
#include "Scene.hpp"
#include "Debug/New.hpp"
using namespace engine;
/*
GameScene::GameScene(const std::string &pName) : Scene(pName){
}
GameInput::GameInput(const std::string &pName) : Input(pName){
}
bool GameScene::Start(){
// Recuperation de la fenetre
mWindow = &(mKernel->GetWindow().GetWindow());
cur... | C++ |
#include "Scene.hpp"
#include "Debug/New.hpp"
#include <iostream>
using namespace engine;
f32 ElapsedTime;
bool paused = false;
int main(){
try{
ILogger::Init();
Settings::Call().Parse();
ResourceManager::Call().AddPath("Data/shaders", "Shader");
ResourceManager::Call().AddPath("Data/textures", "Image");
... | C++ |
#ifndef SCENE_HPP
#define SCENE_HPP
#include "Engine.hpp"
/*
class GameScene : public engine::task::Scene{
public:
GameScene(const std::string &pName);
bool Start();
void Stop();
void Update();
engine::Clock clk, fpsTimer;
f32 elapsedTime;
engine::Camera cam;
engine::Text mousePos, fps;
engine::Texture te... | C++ |
#include <iostream>
using namespace std;
void whoIsYavor();
int main()
{
whoIsYavor();
system("pause");
return 0;
}
void whoIsYavor()
{
cout<<"He is the best!\n";
}
| C++ |
#include "WindowHelper.h"
#include "D3D11.h"
LRESULT CALLBACK WindowProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
L... | C++ |
//////////////////////////////////////////////////
// Helper file for Windows (WinMain)
//////////////////////////////////////////////////
#include <windows.h>
#include <windowsx.h>
#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
#define BORDERLESS_WINDOW
namespace WH{
// Calculate the proper size for ... | C++ |
#pragma once
#include <d3d11.h>
#include <d3dx11.h>
#include <d3dx10.h>
#pragma comment (lib, "d3d11.lib")
#pragma comment (lib, "d3dx11.lib")
#pragma comment (lib, "d3dx10.lib")
#include <stdio.h>
namespace D3D{
// Test for result error
inline void CheckResult(HRESULT hr){
if(hr != S_OK)
printf("Fai... | C++ |
#include "D3D11.h"
D3D11::~D3D11(void){
}
D3D11* D3D11::Get(){
static D3D11 instance;
return &instance;
}
void D3D11::Init(HWND hWnd){
DXGI_SWAP_CHAIN_DESC scd;
ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));
scd.BufferCount = 1;
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scd.BufferUsa... | C++ |
#pragma once
#include "D3DHelper.h"
class D3D11{
public:
~D3D11(void);
static D3D11* Get();
void Init(HWND hWnd);
void Clean();
private:
D3D11(void){}
IDXGISwapChain *m_swapchain;
ID3D11Device *m_device;
ID3D11DeviceContext *m_devcon;
ID3D11RenderTargetView *m_backbuffer;
}; | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "DiagnosticsBase.h"
#include <cassert>
namespace pp
{
Diagnostics::~Diagnostics()
{
}
void Diagnostics::report(ID id,
... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "Lexer.h"
namespace pp
{
Lexer::~Lexer()
{
}
} // namespace pp
| C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_MACRO_EXPANDER_H_
#define COMPILER_PREPROCESSOR_MACRO_EXPANDER_H_
#include <cassert>
#include <memory>
#incl... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_INPUT_H_
#define COMPILER_PREPROCESSOR_INPUT_H_
#include <stddef.h>
#include <vector>
namespace pp
{
// Ho... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_DIRECTIVE_PARSER_H_
#define COMPILER_PREPROCESSOR_DIRECTIVE_PARSER_H_
#include "Lexer.h"
#include "Macro.h"
... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_MACRO_H_
#define COMPILER_PREPROCESSOR_MACRO_H_
#include <map>
#include <string>
#include <vector>
namespac... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_SOURCE_LOCATION_H_
#define COMPILER_PREPROCESSOR_SOURCE_LOCATION_H_
namespace pp
{
struct SourceLocation
{
... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_TOKEN_H_
#define COMPILER_PREPROCESSOR_TOKEN_H_
#include <ostream>
#include <string>
#include "SourceLocati... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "Input.h"
#include <algorithm>
#include <cassert>
#include <cstring>
namespace pp
{
Input::Input() : mCount(0), mString(0)
{
}
... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "Preprocessor.h"
#include <cassert>
#include <sstream>
#include "DiagnosticsBase.h"
#include "DirectiveParser.h"
#include "Macro... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// numeric_lex.h: Functions to extract numeric values from string.
#ifndef COMPILER_PREPROCESSOR_NUMERIC_LEX_H_
#define COMPILER_PREPROCES... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "Macro.h"
#include "Token.h"
namespace pp
{
bool Macro::equals(const Macro& other) const
{
return (type == other.type) &&
... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_LEXER_H_
#define COMPILER_PREPROCESSOR_LEXER_H_
namespace pp
{
struct Token;
class Lexer
{
public:
v... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "Token.h"
#include <cassert>
#include "numeric_lex.h"
namespace pp
{
void Token::reset()
{
type = 0;
flags = 0;
lo... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_PREPROCESSOR_H_
#define COMPILER_PREPROCESSOR_PREPROCESSOR_H_
#include <stddef.h>
#include "pp_utils.h"
na... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "DirectiveParser.h"
#include <cassert>
#include <cstdlib>
#include <sstream>
#include "DiagnosticsBase.h"
#include "DirectiveHan... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "DirectiveHandlerBase.h"
namespace pp
{
DirectiveHandler::~DirectiveHandler()
{
}
} // namespace pp
| C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "MacroExpander.h"
#include <algorithm>
#include <sstream>
#include "DiagnosticsBase.h"
#include "Token.h"
namespace pp
{
class... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_TOKENIZER_H_
#define COMPILER_PREPROCESSOR_TOKENIZER_H_
#include "Input.h"
#include "Lexer.h"
#include "pp_u... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_EXPRESSION_PARSER_H_
#define COMPILER_PREPROCESSOR_EXPRESSION_PARSER_H_
#include "pp_utils.h"
namespace pp
... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_DIRECTIVE_HANDLER_H_
#define COMPILER_PREPROCESSOR_DIRECTIVE_HANDLER_H_
#include <string>
namespace pp
{
s... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_PREPROCESSOR_DIAGNOSTICS_H_
#define COMPILER_PREPROCESSOR_DIAGNOSTICS_H_
#include <string>
namespace pp
{
struct Source... | C++ |
/* A Bison parser, made by GNU Bison 2.7. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as publi... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/ParseHelper.h"
#include <stdarg.h>
#include <stdio.h>
#include "compiler/glslang.h"
#include "compiler/preprocess... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/OutputGLSLBase.h"
#include "compiler/debug.h"
#include <cfloat>
namespace
{
TString arrayBrackets(const TType& ty... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/VariableInfo.h"
static TString arrayBrackets(int index)
{
TStringStream stream;
stream << "[" << index << ... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _CONSTANT_UNION_INCLUDED_
#define _CONSTANT_UNION_INCLUDED_
#include <assert.h>
class ConstantUnion {
public:
ConstantUn... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/InitializeParseContext.h"
#include "compiler/osinclude.h"
OS_TLSIndex GlobalParseContextIndex = OS_INVALID_TLS_INDEX;
... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/Diagnostics.h"
#include "compiler/debug.h"
#include "compiler/InfoSink.h"
#include "compiler/preprocessor/SourceLocatio... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_DIRECTIVE_HANDLER_H_
#define COMPILER_DIRECTIVE_HANDLER_H_
#include "compiler/ExtensionBehavior.h"
#include "compiler/Pra... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/osinclude.h"
//
// This file contains contains the window's specific functions
//
#if !defined(ANGLE_OS_WIN)
#erro... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// UnfoldShortCircuit is an AST traverser to output short-circuiting operators as if-else statements.
// The results are assigned to s#... | C++ |
//
// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/VariablePacker.h"
#include <algorithm>
#include "compiler/ShHandle.h"
namespace {
int GetSortOrder(ShDataType type... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/intermediate.h"
//
// Traverse the intermediate representation tree, and
// call a node type specific function for... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
//
// Definition of the in-memory high-level intermediate representation
// of shaders. This is a tree that parser creates.
//
// Nod... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/TranslatorHLSL.h"
#include "compiler/InitializeParseContext.h"
#include "compiler/OutputHLSL.h"
TranslatorHLSL::T... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _COMMON_INCLUDED_
#define _COMMON_INCLUDED_
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include "... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/BuiltInFunctionEmulator.h"
#include "compiler/SymbolTable.h"
namespace {
// we use macros here instead of functi... | C++ |
//
// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/BuiltInFunctionEmulator.h"
#include "compiler/DetectCallDepth.h"
#include "compiler/ForLoopUnroll.h"
#include "comp... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/localintermediate.h"
//
// Two purposes:
// 1. Show an example of how to iterate tree. Functions can
// also... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_DETECT_RECURSION_H_
#define COMPILER_DETECT_RECURSION_H_
#include "GLSLANG/ShaderLang.h"
#include <limits.h>
#inclu... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _POOLALLOC_INCLUDED_
#define _POOLALLOC_INCLUDED_
#ifdef _DEBUG
#define GUARD_BLOCKS // define to enable guard block sanity ... | C++ |
//
// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/VersionGLSL.h"
static const int GLSL_VERSION_110 = 110;
static const int GLSL_VERSION_120 = 120;
// We need to sc... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/DirectiveHandler.h"
#include <sstream>
#include "compiler/debug.h"
#include "compiler/Diagnostics.h"
static TBehavior... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/TranslatorESSL.h"
#include "compiler/OutputESSL.h"
TranslatorESSL::TranslatorESSL(ShShaderType type, ShShaderSpec... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/ForLoopUnroll.h"
namespace {
class IntegerForLoopUnrollMarker : public TIntermTraverser {
public:
virtual bo... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
//
// Build the intermediate representation.
//
#include <float.h>
#include <limits.h>
#include <algorithm>
#include "compiler/HashN... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_TRANSLATORESSL_H_
#define COMPILER_TRANSLATORESSL_H_
#include "compiler/ShHandle.h"
class TranslatorESSL : public T... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_OUTPUTHLSL_H_
#define COMPILER_OUTPUTHLSL_H_
#include <list>
#include <set>
#include <map>
#define GL_APICALL
#incl... | C++ |
//
// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _TYPES_INCLUDED
#define _TYPES_INCLUDED
#include "compiler/BaseTypes.h"
#include "compiler/Common.h"
#include "compiler/debug... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/intermediate.h"
class TAliveTraverser : public TIntermTraverser {
public:
TAliveTraverser(TQualifier q) : TInt... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef CROSSCOMPILERGLSL_OUTPUTESSL_H_
#define CROSSCOMPILERGLSL_OUTPUTESSL_H_
#include "compiler/OutputGLSLBase.h"
class TOutputES... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// SearchSymbol is an AST traverser to detect the use of a given symbol name
//
#include "compiler/SearchSymbol.h"
#include "compiler... | C++ |
//
// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/intermediate.h"
struct TLoopIndexInfo {
int id;
int initValue;
int stopValue;
int incrementValue;
T... | C++ |
//
// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_MAP_LONG_VARIABLE_NAMES_H_
#define COMPILER_MAP_LONG_VARIABLE_NAMES_H_
#include "GLSLANG/ShaderLang.h"
#include "co... | C++ |
/* A Bison parser, made by GNU Bison 2.7. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as publi... | C++ |
//
// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/OutputESSL.h"
TOutputESSL::TOutputESSL(TInfoSinkBase& objSink,
ShArrayIndexClampingStrate... | C++ |
//
// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
//
// Symbol table for parsing. Most functionaliy and main ideas
// are documented in the header file.
//
#if defined(_MSC_VER)
#pra... | C++ |
//
// Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include <math.h>
#include <stdlib.h>
#include "util.h"
#ifdef _MSC_VER
#include <locale.h>
#else
#include <sstream>
#endif
doub... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _EXTENSION_BEHAVIOR_INCLUDED_
#define _EXTENSION_BEHAVIOR_INCLUDED_
#include <map>
#include <string>
typedef enum
{
EBhR... | C++ |
//
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_TRANSLATORHLSL_H_
#define COMPILER_TRANSLATORHLSL_H_
#include "compiler/ShHandle.h"
#include "compiler/Uniform.h"
c... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _INITIALIZE_INCLUDED_
#define _INITIALIZE_INCLUDED_
#include "compiler/Common.h"
#include "compiler/ShHandle.h"
#include "com... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef COMPILER_VERSIONGLSL_H_
#define COMPILER_VERSIONGLSL_H_
#include "GLSLANG/ShaderLang.h"
#include "compiler/intermediate.h"
/... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#include "compiler/TranslatorGLSL.h"
#include "compiler/TranslatorESSL.h"
//
// This function must be provided to create the actual
/... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
//
// This file contains the posix specific functions
//
#include "compiler/osinclude.h"
#if !defined(ANGLE_OS_POSIX)
#error Trying t... | C++ |
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Contains analysis utilities for dealing with HLSL's lack of support for
// the use of intrinsic functions which (implicitly or explicitly... | C++ |
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef _LOCAL_INTERMEDIATE_INCLUDED_
#define _LOCAL_INTERMEDIATE_INCLUDED_
#include "GLSLANG/ShaderLang.h"
#include "compiler/interm... | C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.