void WindowTree::onRenderItem( RenderContext & context, const RectInt & window, PointInt & pos, Item * pItem )
{
WindowStyle * pStyle = windowStyle();
ASSERT( pStyle );
Font * pFont = windowStyle()->font();
ASSERT( pFont );
// get the depth of this item
int depth = itemDepth( pItem );
// determine the X position based on it's depth
pos.x = window.left + (depth * m_Indent);
// get the size of the label text
SizeInt labelSize( pFont->size( pItem->sLabel ) );
// determine the height of this item
int height = (int)(labelSize.height + TREE_ITEM_BUFFER);
RectInt itemRect( window.left, pos.y, window.right, pos.y + height );
// check if this item is highlighted or not
if ( m_CursorInWindow && itemRect.inRect( m_LastCursorPosition ) )
onHighlight( pItem );
PrimitiveMaterial::push( context.display(), WHITE, PrimitiveMaterial::ALPHA );
if ( pItem->dwFlags & BUTTON )
{
bool expanded = (pItem->dwFlags & EXPANDED) != 0;
Color backColor( expanded ? pStyle->backColor() * TREE_SHADE_COLOR : pStyle->backColor() );
Color shadeColor( expanded ? pStyle->borderColor() * TREE_LIGHT_COLOR : pStyle->borderColor() * TREE_SHADE_COLOR );
Color lightColor( expanded ? pStyle->borderColor() * TREE_SHADE_COLOR : pStyle->borderColor() * TREE_LIGHT_COLOR );
// render the button
pushBackground( context, itemRect, backColor, TREE_BUTTON_STYLE, TREE_BUTTON_BORDER );
pushBorder( context, itemRect, lightColor, shadeColor, TREE_BUTTON_STYLE, TREE_BUTTON_BORDER );
// draw glow around this object if the mouse is currently over this button
if ( m_pCursorOver == pItem )
pushGlow( context, itemRect, TREE_GLOW_SIZE, TREE_GLOW_INNER, TREE_GLOW_OUTER, TREE_BUTTON_STYLE, TREE_BUTTON_BORDER );
// place the label in the center of the button
PointInt labelPos( itemRect.center() - PointInt( labelSize.width / 2, labelSize.height / 2 ) );
// draw the label
Font::push( context.display(), pFont, labelPos, pItem->sLabel, pItem->cColor );
}
else
{
if ( m_pSelected == pItem )
pushBackground( context, itemRect, pStyle->highColor(), 0, 0 );
if ( m_pCursorOver == pItem )
pushGlow( context, itemRect, TREE_GLOW_SIZE, TREE_GLOW_INNER, TREE_GLOW_OUTER, 0, 0 );
PointInt labelPos( pos.x, (int)(pos.y + (TREE_ITEM_BUFFER / 2)) );
// render the label text`
Font::push( context.display(), pFont, labelPos, pItem->sLabel, pItem->cColor );
}
// move y down
pos.y += (int)(height + WINDOW_TREE_SPACING);
}
// Initialize the engine
void Demo::Initialize(HINSTANCE hInstance, int nCmdShow)
{
// Grab instance
Demo* pDemo = Demo::privGetInstance();
// Create window
pDemo->window = pDemo->privCreateGraphicsWindow(hInstance, nCmdShow, "Bricks Demo", GAME_WIDTH, GAME_HEIGHT);
// Initialize Direct3D
pDemo->privInitDevice();
pDemo->privCreateShader();
pDemo->privCreateBuffers();
// initialize motion blur
pDemo->motionBlur.initialize(200);
pDemo->motionBlur.setBlurTime(0.5f);
// Set up camera
pDemo->cam.setViewport(0, 0, GAME_WIDTH, GAME_HEIGHT);
pDemo->cam.setPerspective(35.0f, float(GAME_WIDTH) / float(GAME_HEIGHT), 1.0f, 4500.0f);
pDemo->cam.setOrientAndPosition(Vect(0.0f, 1.0f, 0.0f), Vect(0.0f, 50.0f, -10.0f), Vect(0.0f, 50.0f, 0.0f));
pDemo->cam.updateCamera();
pDemo->projection = pDemo->cam.getProjMatrix();
pDemo->projection.T();
pDemo->deviceCon->UpdateSubresource(pDemo->projectionBuffer, 0, nullptr, &pDemo->projection, 0, 0);
// Set up Lighting
Vect lightDir(20.0f, 100.0f, 100.0f);
lightDir.norm();
Vect lightColor(1.0f, 1.0f, 1.0f, 1.0f);
pDemo->lightInfo.color = lightColor;
pDemo->lightInfo.direction = lightDir;
pDemo->globalLightDir = lightDir;
pDemo->deviceCon->UpdateSubresource(pDemo->lightBuffer, 0, nullptr, &pDemo->lightInfo, 0, 0);
};
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
RendererImplemented::RendererImplemented( int32_t squareMaxCount )
: m_reference ( 1 )
, m_device ( NULL )
, m_context ( NULL )
, m_vertexBuffer( NULL )
, m_indexBuffer ( NULL )
, m_squareMaxCount ( squareMaxCount )
, m_coordinateSystem ( ::Effekseer::CoordinateSystem::RH )
, m_renderState ( NULL )
, m_restorationOfStates( true )
, m_shader(nullptr)
, m_shader_no_texture(nullptr)
, m_shader_distortion(nullptr)
, m_shader_no_texture_distortion(nullptr)
, m_standardRenderer(nullptr)
, m_background(nullptr)
, m_distortingCallback(nullptr)
{
::Effekseer::Vector3D direction( 1.0f, 1.0f, 1.0f );
SetLightDirection( direction );
::Effekseer::Color lightColor( 255, 255, 255, 255 );
SetLightColor( lightColor );
::Effekseer::Color lightAmbient( 0, 0, 0, 0 );
SetLightAmbientColor( lightAmbient );
m_state = new OriginalState();
#ifdef __EFFEKSEER_RENDERER_INTERNAL_LOADER__
EffekseerRenderer::PngTextureLoader::Initialize();
#endif
}
static void paintButtonLike(RenderTheme* theme, RenderObject* o, const RenderObject::PaintInfo& i, const IntRect& rect)
{
SkCanvas* const canvas = i.context->platformContext()->canvas();
SkPaint paint;
SkRect skrect;
const int right = rect.x() + rect.width();
const int bottom = rect.y() + rect.height();
SkColor baseColor = SkColorSetARGB(0xff, 0xdd, 0xdd, 0xdd);
if (o->style()->hasBackground())
baseColor = o->style()->backgroundColor().rgb();
double h, s, l;
Color(baseColor).getHSL(h, s, l);
// Our standard gradient is from 0xdd to 0xf8. This is the amount of
// increased luminance between those values.
SkColor lightColor(brightenColor(h, s, l, 0.105));
// If the button is too small, fallback to drawing a single, solid color
if (rect.width() < 5 || rect.height() < 5) {
paint.setColor(baseColor);
skrect.set(rect.x(), rect.y(), right, bottom);
canvas->drawRect(skrect, paint);
return;
}
const int borderAlpha = theme->isHovered(o) ? 0x80 : 0x55;
paint.setARGB(borderAlpha, 0, 0, 0);
canvas->drawLine(rect.x() + 1, rect.y(), right - 1, rect.y(), paint);
canvas->drawLine(right - 1, rect.y() + 1, right - 1, bottom - 1, paint);
canvas->drawLine(rect.x() + 1, bottom - 1, right - 1, bottom - 1, paint);
canvas->drawLine(rect.x(), rect.y() + 1, rect.x(), bottom - 1, paint);
paint.setARGB(0xff, 0, 0, 0);
SkPoint p[2];
const int lightEnd = theme->isPressed(o) ? 1 : 0;
const int darkEnd = !lightEnd;
p[lightEnd].set(SkIntToScalar(rect.x()), SkIntToScalar(rect.y()));
p[darkEnd].set(SkIntToScalar(rect.x()), SkIntToScalar(bottom - 1));
SkColor colors[2];
colors[0] = lightColor;
colors[1] = baseColor;
SkShader* shader = SkGradientShader::CreateLinear(
p, colors, NULL, 2, SkShader::kClamp_TileMode, NULL);
paint.setStyle(SkPaint::kFill_Style);
paint.setShader(shader);
shader->unref();
skrect.set(rect.x() + 1, rect.y() + 1, right - 1, bottom - 1);
canvas->drawRect(skrect, paint);
paint.setShader(NULL);
paint.setColor(brightenColor(h, s, l, -0.0588));
canvas->drawPoint(rect.x() + 1, rect.y() + 1, paint);
canvas->drawPoint(right - 2, rect.y() + 1, paint);
canvas->drawPoint(rect.x() + 1, bottom - 2, paint);
canvas->drawPoint(right - 2, bottom - 2, paint);
}
Color<float> PhongMaterial::sample(Ray3 ray, vector3D<float> position, vector3D<float> normal)
{
vector3D<float> lightDir = vector3D<float>(1.0f, 1.0f, 1.0f).normalize();
Color<float> lightColor(1.0f, 1.0f, 1.0f);
float NdotL = dot(normal, lightDir);
vector3D<float> H = (lightDir - ray.direction).normalize();
float NdotH = dot(normal, H);
Color<float> diffuseTerm = diffuse*(NdotL> 0?NdotL:0);
auto temp = (NdotH > 0 ? NdotH : 0);
Color<float> specularTerm = specular*(pow(temp, shininess));
return lightColor*(diffuseTerm + specularTerm);
}
void RasNormalMap::FragmentPS( SFragment& frag )
{
SColor texColor(SColor::WHITE), lightColor(SColor::WHITE);
SMaterial* pMaterial = frag.pMaterial;
if(pMaterial->pDiffuseMap && pMaterial->bUseBilinearSampler)
{
pMaterial->pDiffuseMap->Tex2D_Bilinear(frag.uv, texColor, frag.texLod);
}
else if(pMaterial->pDiffuseMap)
{
pMaterial->pDiffuseMap->Tex2D_Point(frag.uv, texColor, frag.texLod);
}
SLightingContext_NormalMap lc;
lc.uv = &frag.uv;
lc.lightDirTS = &frag.lightDirTS;
lc.hVectorTS = &frag.hVectorTS;
DoPerPixelLighting(lightColor, &lc, pMaterial);
// Don't modify alpha [1/19/2014 mavaL]
float alpha = texColor.a;
texColor *= lightColor;
texColor.a = alpha;
texColor.Saturate();
DWORD& dwDestColor = *frag.finalColor;
#if USE_OIT == 0
SColor destPixelColor;
destPixelColor.SetAsInt(dwDestColor);
DoAlphaBlending(destPixelColor, texColor, destPixelColor, pMaterial);
dwDestColor = destPixelColor.GetAsInt();
#else
texColor.a *= pMaterial->transparency;
dwDestColor = texColor.GetAsInt();
#endif
#if USE_PROFILER == 1
g_env.profiler->AddRenderedPixel();
#endif
}
/*
* Calculate reflection color
*/
color refColor(const intersection *inter, const ray *srcRay) {
color cR = BLACK;
if (srcRay->depth == MAX_DEPTH)
return cR;
intersection refInter;
vec3 refVec = vector_reflect(srcRay->dir, inter->normal);
ray refRay; // Ray from object to other object
ray_init(&refRay, inter->position, refVec, EPSILON, 1000, srcRay->depth + 1);
int bounceFound = 0;
for (int k = 0; k < object_count; ++k) {
bounceFound += intersect(&refRay, &(scene[k]), &refInter);
}
color refCoef = reflectCoef(inter->mat.reflect_coef, inter->normal, srcRay->dir);
if (bounceFound)
cR = vector_vec_mul(refCoef, vector_add(refColor(&refInter, &refRay), lightColor(&refInter, &refRay)));
else
cR = vector_vec_mul(refCoef, SKY_COLOR);
return cR;
}
void VR_Canvas::privRenderState(Camera * OrthoCamera)
{
///////////////SetRenderState////////////////
glViewport(0,0,1280,800);
this->ModelView = this->LocalToWorld * OrthoCamera->getViewMatrix();
Matrix mvp = this->ModelView * OrthoCamera->getProjMatrix();
glEnable(GL_BLEND);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
Vect lightColor( 2.5f, 2.5f, 2.5f, 1.0f);
Vect lightPos(0.0f, 0.0f, 5.0f);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF, &ModelView, &OrthoCamera->getProjMatrix(), &lightPos, &lightColor, 0);
/////////////////////////////////////////////
}
int scene::loadLight(string lightid){
int id = atoi(lightid.c_str());
if(id!=lights.size()){
cout << "ERROR: LIGHT ID does not match expected number of lights" << endl;
return -1;
}else{
cout << "Loading Light " << id << "..." << endl;
light newLight;
string line;
//load light type
utilityCore::safeGetline(fp_in,line);
if (!line.empty() && fp_in.good()){
if(strcmp(line.c_str(), "point")==0){
cout << "Creating new point light..." << endl;
newLight.type = POINT;
}
}
//load static properties
for(int i=0; i<3; i++){
string line;
utilityCore::safeGetline(fp_in,line);
vector<string> tokens = utilityCore::tokenizeString(line);
if(strcmp(tokens[0].c_str(), "INTENSITY")==0){
newLight.intensity = atof(tokens[1].c_str());
}else if(strcmp(tokens[0].c_str(), "COLOR")==0){
glm::vec3 lightColor( atof(tokens[1].c_str()), atof(tokens[2].c_str()), atof(tokens[3].c_str()) );
newLight.color = lightColor;
}else if(strcmp(tokens[0].c_str(), "POS")==0){
glm::vec3 lightPos( atof(tokens[1].c_str()), atof(tokens[2].c_str()), atof(tokens[3].c_str()) );
newLight.position = lightPos;
}
}
lights.push_back(newLight);
return 1;
}
}
void raytrace() {
vec3 xR = theCamera.xdir;
vec3 yR = vector_float_mul(1 / theCamera.aspect, theCamera.ydir);
vec3 zR = vector_float_mul(1 / (tanf(0.5 * ((theCamera.fov / 180) * M_PI))), theCamera.zdir);
int halfWidth = WIDTH / 2, halfHeight = HEIGHT / 2;
for (int i = 0; i < WIDTH; ++i) {
for (int j = 0; j < HEIGHT; ++j) {
color c = BLACK;
float deltas[4][2] = { { .25f, .25f }, { .25f, .75f }, { .75f, .25f }, { .75f, .75f } };
ray rays[4];
for (int n = 0; n < 4; ++n) {
// Calculate ray
vec3 x = vector_float_mul((i + deltas[n][0] - halfWidth) / halfWidth, xR);
vec3 y = vector_float_mul((j + deltas[n][1] - halfHeight) / halfHeight, yR);
vec3 d = vector_add(x, y);
d = vector_add(d, zR);
ray_init(&rays[n], theCamera.position, d);
// Calculate intersection
intersection inter;
int found = 0;
for (int k = 0; k < object_count; ++k) {
found += (intersect(&rays[n], &(scene[k]), &inter)); // Keep the closest intersection
}
// Calculate pixel color
if (found) {
color cD = lightColor(&inter, &rays[n]);
color cR = refColor(&inter, &rays[n]);
c = vector_add(c, vector_add(cD, cR));
} else
c = vector_add(c, SKY_COLOR);
}
// Mean
output_image[j * WIDTH + i] = vector_float_mul(1.0f / 4.0f, c);
}
// Progress
printf("%d%%\n", (int) (((float) i / WIDTH) * 100));
}
printf("Done :)\n");
}
int main() {
// Initialize GLFW and set some hints that will create an OpenGL 3.3 context
// using core profile.
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create a fixed 800x600 window that is not resizable.
GLFWwindow* window = glfwCreateWindow(kWindowWidth, kWindowHeight, "LearnGL", nullptr, nullptr);
if (window == nullptr) {
std::cerr << "Failed to created GLFW window" << std::endl;
glfwTerminate();
return 1;
}
// Create an OpenGL context and pass callbacks to GLFW.
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, keyCallback);
glfwSetCursorPosCallback(window, mouseCallback);
glfwSetScrollCallback(window, scrollCallback);
// Lock the mouse in the window.
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) {
std::cerr << "Failed to initialize GLEW" << std::endl;
glfwTerminate();
return 1;
}
// Create a viewport the same size as the window. glfwGetFramebufferSize is
// used rather than the size constants since some windowing systems have a
// discrepancy between window size and framebuffer size
// (e.g HiDPi screen coordinates),
int fbWidth, fbHeight;
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
glViewport(0, 0, fbWidth, fbHeight);
// Enable use of the depth buffer since we're working on 3D and want to
// prevent overlapping polygon artifacts.
glEnable(GL_DEPTH_TEST);
// Read and compile the vertex and fragment shaders using
// the shader helper class.
Shader shader("glsl/vertex.glsl", "glsl/fragment.glsl", "glsl/geometry.glsl");
Shader lampShader("glsl/lampvertex.glsl", "glsl/lampfragment.glsl");
Shader postShader("glsl/post_vert.glsl", "glsl/post_frag.glsl");
Shader gsShader("glsl/gs_vert.glsl", "glsl/gs_frag.glsl", "glsl/gs_geo.glsl");
GLuint containerTexture = loadTexture("assets/container2.png");
GLuint containerSpecular = loadTexture("assets/container2_specular.png");
GLuint containerEmission = loadTexture("assets/matrix.jpg");
// Create and bind a framebuffer.
GLuint FBO;
glGenFramebuffers(1, &FBO);
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
// Create an empty texture to be attached to the framebuffer.
// Give a null pointer to glTexImage2D since we want an empty texture.
GLuint frameColorBuffer;
glGenTextures(1, &frameColorBuffer);
glBindTexture(GL_TEXTURE_2D, frameColorBuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, fbWidth, fbHeight, 0, GL_RGB,
GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
// Attach the texture to the framebuffer.
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
frameColorBuffer, 0);
// Create a renderbuffer to hold our depth and stencil buffers with a size
// of the window's framebuffer size.
GLuint RBO;
glGenRenderbuffers(1, &RBO);
glBindRenderbuffer(GL_RENDERBUFFER, RBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8,
fbWidth, fbHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// Attach the render buffer (provides depth and stencil) to the framebuffer.
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, RBO);
// Panic if the framebuffer is somehow incomplete at this stage. This should
// never happen if we attached the texture but it's good practice to check.
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
std::cerr << "ERROR: Framebuffer is not complete!" << std::endl;
glfwTerminate();
return 1;
}
// Unbind the framebuffer since we want the main scene to be drawn
// to be drawn to the main window.
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Container mesh data.
GLfloat vertices[] = {
// Vertices // Normals // UVs
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f
};
// Points for the geometry shader tutorial.
GLfloat points[] = {
-0.5f, 0.5f, 1.0f, 0.0f, 0.0f, // Top-left
0.5f, 0.5f, 0.0f, 1.0f, 0.0f, // Top-right
0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // Bottom-right
-0.5f, -0.5f, 1.0f, 1.0f, 0.0f // Bottom-left
};
// Positions all containers
glm::vec3 cubePositions[] = {
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3( 2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3( 1.3f, -2.0f, -2.5f),
glm::vec3( 1.5f, 2.0f, -2.5f),
glm::vec3( 1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
// Create a VBO to store the vertex data, an EBO to store indice data, and
// create a VAO to retain our vertex attribute pointers.
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
// Fill the VBO and set vertex attributes.
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
// Create a lamp box thing using the existing container VBO.
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
// Use the container's VBO and set vertex attributes.
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
// Vertex attributes for the frame quad in NDC.
GLfloat frameVertices[] = {
// Positions // UVs
-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f
};
// Create a VBO and VAO for the post-processing step.
GLuint frameVBO, frameVAO;
glGenVertexArrays(1, &frameVAO);
glGenBuffers(1, &frameVBO);
glBindVertexArray(frameVAO);
glBindBuffer(GL_ARRAY_BUFFER, frameVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(frameVertices), frameVertices,
GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
(GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
(GLvoid*)(2 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
// Create a VBO and VAO for the geometry shader test. The VBO will contain
// only the position.
GLuint pointsVBO, pointsVAO;
glGenVertexArrays(1, &pointsVAO);
glGenBuffers(1, &pointsVBO);
glBindVertexArray(pointsVAO);
glBindBuffer(GL_ARRAY_BUFFER, pointsVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
(GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
(GLvoid*)(2 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
// Create a perspective camera to fit the viewport.
screenWidth = (GLfloat)fbWidth;
screenHeight = (GLfloat)fbHeight;
camera = PerspectiveCamera(
glm::vec3(0.0f, 0.0f, 3.0f),
glm::vec3(0.0f, glm::radians(-90.0f), 0.0f),
glm::radians(45.0f),
screenWidth / screenHeight,
0.1f,
100.0f
);
GLfloat delta = 0.0f;
GLfloat lastFrame = 0.0f;
// Light information.
const glm::vec3 directionalLightDir(0.0f, 1.0f, 0.0f);
const glm::vec3 pointLightPositions[] = {
glm::vec3( 0.7f, 0.2f, 2.0f),
glm::vec3( 2.3f, -3.3f, -4.0f),
glm::vec3(-4.0f, 2.0f, -12.0f),
glm::vec3( 0.0f, 0.0f, -3.0f)
};
// Render loop.
while (!glfwWindowShouldClose(window)) {
GLfloat currentFrame = glfwGetTime();
delta = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events.
glfwPollEvents();
move(delta);
// Bind the off screen framebuffer (for post-processing) and clear the
// screen to a nice blue color.
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glClearColor(0.1f, 0.15f, 0.15f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
const GLfloat limitTime = 1.0f;
fovTime += delta;
if (fovTime > limitTime) {
fovTime = limitTime;
}
// Update the perspective to account for changes in fov.
camera.fov = easeOutQuart(fovTime, startFov, (startFov - targetFov) * -1, limitTime);
camera.update();
// Bind the VAO and shader.
glBindVertexArray(VAO);
shader.use();
// Pass the view and projection matrices from the camera.
GLuint viewMatrix = glGetUniformLocation(shader.program, "view");
glUniformMatrix4fv(viewMatrix, 1, GL_FALSE, glm::value_ptr(camera.view));
GLuint projectionMatrix = glGetUniformLocation(shader.program, "projection");
glUniformMatrix4fv(projectionMatrix, 1, GL_FALSE, glm::value_ptr(camera.projection));
// Generate light colors.
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
// Directional light
glUniform3f(glGetUniformLocation(shader.program, "dirLight.direction"), -0.2f, -1.0f, -0.3f);
glUniform3f(glGetUniformLocation(shader.program, "dirLight.ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "dirLight.diffuse"), 0.4f, 0.4f, 0.4f);
glUniform3f(glGetUniformLocation(shader.program, "dirLight.specular"), 0.5f, 0.5f, 0.5f);
// Point light 1
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].position"), pointLightPositions[0].x, pointLightPositions[0].y, pointLightPositions[0].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].diffuse"), 1.0f, 0.0f, 0.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].quadratic"), 0.032);
// Point light 2
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].position"), pointLightPositions[1].x, pointLightPositions[1].y, pointLightPositions[1].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].diffuse"), 0.0f, 1.0f, 0.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].quadratic"), 0.032);
// Point light 3
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].position"), pointLightPositions[2].x, pointLightPositions[2].y, pointLightPositions[2].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].diffuse"), 0.0f, 0.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[2].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[2].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[2].quadratic"), 0.032);
// Point light 4
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].position"), pointLightPositions[3].x, pointLightPositions[3].y, pointLightPositions[3].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].diffuse"), 0.8f, 0.8f, 0.8f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[3].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[3].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[3].quadratic"), 0.032);
// Sport light 1
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].position"), camera.position.x, camera.position.y, camera.position.z);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].direction"), camera.front.x, camera.front.y, camera.front.z);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].ambient"), 0.0f, 0.0f, 0.0f);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].quadratic"), 0.032);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].cutoff"), glm::cos(glm::radians(12.5f)));
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].outerCutoff"), glm::cos(glm::radians(15.5f)));
// Pass material values.
GLuint materialShininess = glGetUniformLocation(shader.program, "material.shininess");
GLuint materialDiffuse = glGetUniformLocation(shader.program, "material.diffuse");
GLuint materialSpecular = glGetUniformLocation(shader.program, "material.specular");
GLuint materialEmission = glGetUniformLocation(shader.program, "material.emission");
glUniform1f(materialShininess, 64.0f);
glUniform1i(materialDiffuse, 0);
glUniform1i(materialSpecular, 1);
glUniform1i(materialEmission, 2);
// Misc values.
GLuint viewPos = glGetUniformLocation(shader.program, "viewPos");
glUniform3f(viewPos, camera.position.x, camera.position.y, camera.position.z);
GLuint time = glGetUniformLocation(shader.program, "time");
glUniform1f(time, glfwGetTime());
// Bind the textures.
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, containerTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, containerSpecular);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, containerEmission);
// Draw multiple containers!
GLuint modelMatrix = glGetUniformLocation(shader.program, "model");
GLuint normalMatrix = glGetUniformLocation(shader.program, "normalMatrix");
for (GLuint i = 0; i < 10; i++) {
// Apply world transformations.
model = glm::mat4();
model = glm::translate(model, cubePositions[i]);
model = glm::rotate(model, i * 20.0f, glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
// Calculate the normal matrix on the CPU (keep them normals perpendicular).
normal = glm::mat3(glm::transpose(glm::inverse(model)));
glUniformMatrix3fv(normalMatrix, 1, GL_FALSE, glm::value_ptr(normal));
// Draw the container.
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Bind the VAO and shader.
glBindVertexArray(lightVAO);
lampShader.use();
// Pass the view and projection matrices from the camera.
viewMatrix = glGetUniformLocation(lampShader.program, "view");
glUniformMatrix4fv(viewMatrix, 1, GL_FALSE, glm::value_ptr(camera.view));
projectionMatrix = glGetUniformLocation(lampShader.program, "projection");
glUniformMatrix4fv(projectionMatrix, 1, GL_FALSE, glm::value_ptr(camera.projection));
for (GLuint i = 0; i < 4; i++) {
// Apply world transformations.
model = glm::mat4();
model = glm::translate(model, pointLightPositions[i]);
model = glm::scale(model, glm::vec3(0.2f));
modelMatrix = glGetUniformLocation(lampShader.program, "model");
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
// Draw the lamp.
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Draw something with the geometry shader program.
//glDisable(GL_DEPTH_TEST);
//gsShader.use();
//glBindVertexArray(pointsVAO);
//glDrawArrays(GL_POINTS, 0, 4);
//glBindVertexArray(0);
//glEnable(GL_DEPTH_TEST);
// Unbind the offscreen framebuffer containing the unprocessed frame.
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
postShader.use();
glBindVertexArray(frameVAO);
// Send the texture sampler to the shader.
GLuint frameTexture = glGetUniformLocation(postShader.program, "frameTexture");
time = glGetUniformLocation(postShader.program, "time");
glUniform1i(frameTexture, 0);
glUniform1f(time, glfwGetTime());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, frameColorBuffer);
// Render the color buffer in the framebuffer to the quad with post shader.
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
// Swap buffers used for double buffering.
glfwSwapBuffers(window);
}
// Destroy the off screen framebuffer.
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDeleteFramebuffers(1, &FBO);
// Properly deallocate the VBO and VAO.
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
// Terminate GLFW and clean any resources before exiting.
glfwTerminate();
return 0;
}
void TinyRendererVisualShapeConverter::render(const float viewMat[16], const float projMat[16])
{
//clear the color buffer
TGAColor clearColor;
clearColor.bgra[0] = 255;
clearColor.bgra[1] = 255;
clearColor.bgra[2] = 255;
clearColor.bgra[3] = 255;
clearBuffers(clearColor);
ATTRIBUTE_ALIGNED16(btScalar modelMat[16]);
btVector3 lightDirWorld(-5,200,-40);
if (m_data->m_hasLightDirection)
{
lightDirWorld = m_data->m_lightDirection;
}
else
{
switch (m_data->m_upAxis)
{
case 1:
lightDirWorld = btVector3(-50.f, 100, 30);
break;
case 2:
lightDirWorld = btVector3(-50.f, 30, 100);
break;
default: {}
};
}
lightDirWorld.normalize();
btVector3 lightColor(1.0,1.0,1.0);
if (m_data->m_hasLightColor)
{
lightColor = m_data->m_lightColor;
}
// printf("num m_swRenderInstances = %d\n", m_data->m_swRenderInstances.size());
for (int i=0;i<m_data->m_swRenderInstances.size();i++)
{
TinyRendererObjectArray** visualArrayPtr = m_data->m_swRenderInstances.getAtIndex(i);
if (0==visualArrayPtr)
continue;//can this ever happen?
TinyRendererObjectArray* visualArray = *visualArrayPtr;
btHashPtr colObjHash = m_data->m_swRenderInstances.getKeyAtIndex(i);
const btCollisionObject* colObj = (btCollisionObject*) colObjHash.getPointer();
for (int v=0;v<visualArray->m_renderObjects.size();v++)
{
TinyRenderObjectData* renderObj = visualArray->m_renderObjects[v];
//sync the object transform
const btTransform& tr = colObj->getWorldTransform();
tr.getOpenGLMatrix(modelMat);
for (int i=0;i<4;i++)
{
for (int j=0;j<4;j++)
{
renderObj->m_projectionMatrix[i][j] = projMat[i+4*j];
renderObj->m_modelMatrix[i][j] = modelMat[i+4*j];
renderObj->m_viewMatrix[i][j] = viewMat[i+4*j];
renderObj->m_localScaling = colObj->getCollisionShape()->getLocalScaling();
renderObj->m_lightDirWorld = lightDirWorld;
renderObj->m_lightColor = lightColor;
}
}
TinyRenderer::renderObject(*renderObj);
}
}
//printf("write tga \n");
//m_data->m_rgbColorBuffer.write_tga_file("camera.tga");
// printf("flipped!\n");
m_data->m_rgbColorBuffer.flip_vertically();
//flip z-buffer and segmentation Buffer
{
int half = m_data->m_swHeight>>1;
for (int j=0; j<half; j++)
{
unsigned long l1 = j*m_data->m_swWidth;
unsigned long l2 = (m_data->m_swHeight-1-j)*m_data->m_swWidth;
for (int i=0;i<m_data->m_swWidth;i++)
{
btSwap(m_data->m_depthBuffer[l1+i],m_data->m_depthBuffer[l2+i]);
btSwap(m_data->m_segmentationMaskBuffer[l1+i],m_data->m_segmentationMaskBuffer[l2+i]);
}
}
}
}
bool gl_GetSpriteLight(AActor *self, fixed_t x, fixed_t y, fixed_t z, subsector_t * subsec, int desaturation, float * out, line_t *line, int side)
{
ADynamicLight *light;
float frac, lr, lg, lb;
float radius;
bool changed = false;
out[0]=out[1]=out[2]=0;
for(int j=0;j<2;j++)
{
// Go through both light lists
FLightNode * node = subsec->lighthead[j];
while (node)
{
light=node->lightsource;
//if (!light->owned || light->target == NULL || light->target->IsVisibleToPlayer())
{
if (!(light->flags2&MF2_DORMANT) &&
(!(light->flags4&MF4_DONTLIGHTSELF) || light->target != self))
{
float dist = FVector3(FIXED2FLOAT(x - light->x), FIXED2FLOAT(y - light->y), FIXED2FLOAT(z - light->z)).Length();
radius = light->GetRadius() * gl_lights_size;
if (dist < radius)
{
frac = 1.0f - (dist / radius);
if (frac > 0)
{
if (line != NULL)
{
if (P_PointOnLineSide(light->x, light->y, line) != side)
{
node = node->nextLight;
continue;
}
}
lr = light->GetRed() / 255.0f * gl_lights_intensity;
lg = light->GetGreen() / 255.0f * gl_lights_intensity;
lb = light->GetBlue() / 255.0f * gl_lights_intensity;
if (light->IsSubtractive())
{
float bright = FVector3(lr, lg, lb).Length();
FVector3 lightColor(lr, lg, lb);
lr = (bright - lr) * -1;
lg = (bright - lg) * -1;
lb = (bright - lb) * -1;
}
out[0] += lr * frac;
out[1] += lg * frac;
out[2] += lb * frac;
changed = true;
}
}
}
}
node = node->nextLight;
}
}
// Desaturate dynamic lighting if applicable
if (desaturation>0 && desaturation<=CM_DESAT31)
{
float gray=(out[0]*77 + out[1]*143 + out[2]*37)/257;
out[0]= (out[0]*(31-desaturation)+ gray*desaturation)/31;
out[1]= (out[1]*(31-desaturation)+ gray*desaturation)/31;
out[2]= (out[2]*(31-desaturation)+ gray*desaturation)/31;
}
return changed;
}
int main() {
GLFWwindow * window = initWindow(windowWidth, windowHeight);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, cursor_callback);
glfwSetScrollCallback(window, scroll_callback);
glEnable(GL_DEPTH_TEST);
// prepare texture loading library(devil)
ilInit();
// prepare an array of vertices
GLfloat vertices[] = {
// Positions // Normals // Texture Coords
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f
};
glm::vec3 cubePositions[] = {
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3( 2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3( 1.3f, -2.0f, -2.5f),
glm::vec3( 1.5f, 2.0f, -2.5f),
glm::vec3( 1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
GLuint lightVBO;
glGenBuffers(1, &lightVBO);
glBindBuffer(GL_ARRAY_BUFFER, lightVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat),
(void*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat),
(void*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
Shader shaders("shader.vert", "shader.frag");
Shader lightShaders("lightShader.vert", "lightShader.frag");
std::cout << "Input path: ";
std::string path;
std::getline(std::cin, path);
std::cout << "path is: " << path << std::endl;
std::cout << "Loading model..." << std::endl;
Model themodel(path.c_str());
std::cout << "Model loaded!" << std::endl;
double last_frame = glfwGetTime();
while (!glfwWindowShouldClose(window)) {
double current_frame = glfwGetTime();
double delta_time = current_frame - last_frame;
last_frame = current_frame;
glfwPollEvents();
do_movement(delta_time);
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat light_pos_angle = glm::radians(60.0f * current_frame);
glm::vec3 light_pos(1.2f + sin(light_pos_angle), 0.0f, 2.0f + cos(light_pos_angle));
glm::vec3 light_dir(-0.2f, -1.0f, -0.3f);
// draw common container
shaders.Use();
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom),
(GLfloat)windowWidth / (GLfloat)windowHeight,
0.01f, 1000.0f);
shaders.SetUniform("view", view);
shaders.SetUniform("projection", projection);
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
//lightColor.r = sin(current_frame * 2.0f);
//lightColor.g = sin(current_frame * 0.7f);
//lightColor.b = sin(current_frame * 1.3f);
shaders.SetUniform("ViewPos", camera.Position);
// directional light
shaders.SetUniform("dirLight.direction", light_dir);
shaders.SetUniform("dirLight.ambient", 0.1f, 0.1f, 0.1f);
shaders.SetUniform("dirLight.diffuse", 0.5f, 0.5f, 0.5f);
shaders.SetUniform("dirLight.specular", 1.0f, 1.0f, 1.0f);
// point light
shaders.SetUniform("pointLights[0].position", light_pos);
shaders.SetUniform("pointLights[0].ambient", lightColor * 0.1f);
shaders.SetUniform("pointLights[0].diffuse", lightColor * 0.5f);
shaders.SetUniform("pointLights[0].specular", 1.0f, 1.0f, 1.0f);
shaders.SetUniform("pointLights[0].constant", 1.0f);
shaders.SetUniform("pointLights[0].linear", 0.09f);
shaders.SetUniform("pointLights[0].quadratic", 0.032f);
shaders.SetUniform("pointLightCount", 1);
glm::vec3 spotLight((GLfloat)flash_light_on);
// spot light
shaders.SetUniform("spotLight.ambient", spotLight * 0.1f);
shaders.SetUniform("spotLight.diffuse", spotLight * 0.5f);
shaders.SetUniform("spotLight.specular", spotLight);
shaders.SetUniform("spotLight.position", camera.Position);
shaders.SetUniform("spotLight.direction", camera.Front);
shaders.SetUniform("spotLight.cutoff", glm::cos(glm::radians(12.5f)));
shaders.SetUniform("spotLight.outerCutoff", glm::cos(glm::radians(17.5f)));
shaders.SetUniform("material.shininess", 10000.0f);
glm::mat4 model = glm::translate(glm::mat4(), glm::vec3(0.2f, -1.0f, 1.0f));
model = glm::scale(model, glm::vec3(0.1f, 0.1f, 0.1f));
shaders.SetUniform("model", model);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(glm::inverse(model)));
shaders.SetUniform("normalMatrix", normalMatrix);
themodel.Draw(shaders);
// draw lamp
lightShaders.Use();
glm::mat4 lightModel = glm::scale(glm::translate(glm::mat4(), light_pos), glm::vec3(0.2f));
lightShaders.SetUniform("view", view);
lightShaders.SetUniform("projection", projection);
lightShaders.SetUniform("model", lightModel);
lightShaders.SetUniform("lightColor", lightColor);
glBindVertexArray(lightVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
void VR_Canvas::RenderCanvas(Camera * OrthoCamera)
{
OrthoCamera;
privTransform();
privRenderState(OrthoCamera);
// this->getAssignedAvatar()->getLeftEye()->getDistort
float DistK[4];
float TexRange[2];
float LensOff[2];
float TexScale=0;
float Aspect=0;
this->ModelView = this->LocalToWorld * OrthoCamera->getViewMatrix();
Vect lightColor( 2.5f, 2.5f, 2.5f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
this->getAssignedAvatar()->getLeftEye()->getDistortionRenderData(DistK, TexRange,LensOff,TexScale, Aspect);
GLuint attribute_v_coord_postproc = glGetAttribLocation(VRManager::getInstance().getShaderProgram(), "v_coord");
GLuint uniform_fbo_texture = glGetUniformLocation(VRManager::getInstance().getShaderProgram(), "fbo_texture");
GLuint uniform_offset = glGetUniformLocation(VRManager::getInstance().getShaderProgram(), "offset");
uniform_offset;attribute_v_coord_postproc;uniform_fbo_texture;
glUseProgram( VRManager::getInstance().getShaderProgram());
GLfloat offset = 0;
glUniform1f(uniform_offset, offset);
glBindTexture(GL_TEXTURE_2D, this->LeftPane.TBO);
glUniform1i(uniform_fbo_texture,0);
glEnableVertexAttribArray(attribute_v_coord_postproc);
glBindVertexArray(this->LeftPane.VAO);
glDrawElements(GL_TRIANGLES, 3*2, GL_UNSIGNED_SHORT, 0);
glBindVertexArray(0);
glDisableVertexAttribArray(attribute_v_coord_postproc);
glBindTexture(GL_TEXTURE_2D,0);
glUseProgram(0);
this->getAssignedAvatar()->getRightEye()->getDistortionRenderData(DistK, TexRange,LensOff,TexScale, Aspect);
glUseProgram( VRManager::getInstance().getShaderProgram());
offset = 1;
glUniform1f(uniform_offset, offset);
glBindTexture(GL_TEXTURE_2D, this->RightPane.TBO);
glUniform1i(uniform_fbo_texture,0);
glEnableVertexAttribArray(attribute_v_coord_postproc);
glBindVertexArray(this->RightPane.VAO);
glDrawElements(GL_TRIANGLES, 3*2, GL_UNSIGNED_SHORT, 0);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D,0);
glDisableVertexAttribArray(attribute_v_coord_postproc);
glUseProgram(0);
}
int main() {
// msaa
glfwWindowHint(GLFW_SAMPLES, 4);
GLFWwindow * window = initWindow(windowWidth, windowHeight);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, cursor_callback);
glfwSetScrollCallback(window, scroll_callback);
glEnable(GL_DEPTH_TEST);
// prepare texture loading library(devil)
init_texture_loading();
//plane
Shader simpleDepthShader("data/shaders/shadow_mapping_depth.vs", "data/shaders/shadow_mapping_depth.frag");
Model ourModel("data/models/nanosuit/nanosuit.obj");
GLfloat planeVertices[] = {
// Positions // Normals // Texture Coords
2.0f, 0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 2.0f, 0.0f,
-2.0f, 0.0f, -2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 2.0f,
-2.0f, 0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
2.0f, 0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 2.0f, 0.0f,
2.0f, 0.0f, -2.0f, 0.0f, 1.0f, 0.0f, 2.0f, 2.0f,
-2.0f, 0.0f, -2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 2.0f
};
// Setup plane VAO xzhs
GLuint planeVBO;
GLuint woodTexture;
GLuint rockTexture;
glGenVertexArrays(1, &planeVAO);
glGenBuffers(1, &planeVBO);
glBindVertexArray(planeVAO);
glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glBindVertexArray(0);
// Load textures
woodTexture = load_texture("data/textures/wood.png");
rockTexture = load_texture("data/textures/rock.jpg");
// Configure depth map FBO
const GLuint SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
GLuint depthMapFBO;
glGenFramebuffers(1, &depthMapFBO);
// - Create depth texture
GLuint depthMap;
glGenTextures(1, &depthMap);
glBindTexture(GL_TEXTURE_2D, depthMap);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
GLfloat borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
//xzhe
Shader shaders("data/shaders/shader.vert", "data/shaders/shader.frag");
Shader colorShaders("data/shaders/shaderColorUniform.vert",
"data/shaders/shaderColorUniform.frag");
Shader domeShaders("data/shaders/dome.vert", "data/shaders/dome.frag");
Shader lightShaders("data/shaders/lightShader.vert", "data/shaders/lightShader.frag");
Shader spriteShaders("data/shaders/spriteShader.vert", "data/shaders/spriteShader.frag");
Shader starShaders("data/shaders/spriteShader.vert", "data/shaders/stars.frag");
std::cout << "Loading models..." << std::endl;
Model dome("data/models/geodesic_dome.obj");
Model landscape("data/models/landscape.obj");
std::cout << "Models loaded!" << std::endl;
std::cout << "Loading extra textures..." << std::endl;
GLuint domeColor = load_texture("data/textures/sky.png", true, GL_MIRRORED_REPEAT, GL_MIRRORED_REPEAT);
GLuint domeGlow = load_texture("data/textures/glow.png", true, GL_MIRRORED_REPEAT, GL_MIRRORED_REPEAT);
Sprite sun("data/textures/sun.png");
Sprite moon("data/textures/moon.png");
Sprite star("data/textures/star.png");
// enable blending!
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// enable msaa(multisample anti-aliasing)
glEnable(GL_MULTISAMPLE);
std::vector<glm::mat4> starModels(256);
for (auto& m : starModels) {
m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(1.0f, 0.0f, 0.0f));
m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(0.0f, 1.0f, 0.0f));
m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(0.0f, 0.0f, 1.0f));
m = glm::translate(m, glm::vec3(5.0f, 0.0f, 0.0f));
m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(1.0f, 0.0f, 0.0f));
m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(0.0f, 1.0f, 0.0f));
}
double last_frame = glfwGetTime();
while (!glfwWindowShouldClose(window)) {
double current_frame = glfwGetTime();
double delta_time = current_frame - last_frame;
last_frame = current_frame;
glfwPollEvents();
do_movement(delta_time);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glViewport(0, 0, windowWidth, windowHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)windowWidth / (float)windowHeight, 0.1f, 100.0f);
glm::mat4 view = camera.GetViewMatrix();
// sun
float sunAngle = current_frame * 30.0f;
glm::mat4 sunModel;
sunModel = glm::rotate(sunModel, glm::radians(sunAngle), glm::vec3(0.0f, 0.0f, 1.0f));
sunModel = glm::translate(sunModel, glm::vec3(3.5f, 0.0f, 0.0f));
glm::vec3 sunPos = glm::vec3(sunModel * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
// moon
float moonAngle = sunAngle + 180.0f;
glm::mat4 moonModel;
moonModel = glm::rotate(moonModel, glm::radians(moonAngle), glm::vec3(0.0f, 0.0f, 1.0f));
moonModel = glm::translate(moonModel, glm::vec3(3.5f, 0.0f, 0.0f));
// directional light
DirLight dirLight(-sunPos, glm::vec3(0.8f, 0.8f, 0.8f));
// point light
GLfloat light_pos_angle = glm::radians(60.0f * current_frame);
glm::vec3 light_pos(1.2f + sin(light_pos_angle), 0.0f, 2.0f + cos(light_pos_angle));
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
lightColor.r = sin(current_frame * 2.0f);
lightColor.g = sin(current_frame * 0.7f);
lightColor.b = sin(current_frame * 1.3f);
PointLight pointLight(light_pos, lightColor * 0.5f);
// spot light
SpotLight spotLight(camera.Position, camera.Front,
glm::vec3((GLfloat)flash_light_on));
shaders.Use();
shaders.SetUniform("view", view);
shaders.SetUniform("projection", projection);
shaders.SetUniform("ViewPos", camera.Position);
dirLight.SetUniforms(shaders, "dirLight");
pointLight.SetUniforms(shaders, "pointLights[0]");
shaders.SetUniform("pointLightCount", 0);
spotLight.SetUniforms(shaders, "spotLight");
shaders.SetUniform("material.shininess", 16.0f);
colorShaders.Use();
colorShaders.SetUniform("view", view);
colorShaders.SetUniform("projection", projection);
colorShaders.SetUniform("ViewPos", camera.Position);
dirLight.SetUniforms(colorShaders, "dirLight");
//pointLight.SetUniforms(colorShaders, "pointLights[0]");
colorShaders.SetUniform("pointLightCount", 0);
spotLight.SetUniforms(colorShaders, "spotLight");
colorShaders.SetUniform("material.shininess", 1.8f);
// make the dome and landscape pinned
glm::mat4 pinnedView = glm::lookAt(glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f) + camera.Front,
glm::vec3(0.0f, 1.0f, 0.0f));
if (enable_stars) {
// stars
starShaders.Use();
starShaders.SetUniform("view", view);
starShaders.SetUniform("projection", projection);
starShaders.SetUniform("groundBases[0]", 1.0f, 0.0f, 0.0f);
starShaders.SetUniform("groundBases[1]", 0.0f, 0.0f, 1.0f);
starShaders.SetUniform("groundUp", 0.0f, 1.0f, 0.0f);
starShaders.SetUniform("sunPos", sunPos);
for (const auto& m : starModels) {
glm::mat4 model = glm::rotate(glm::mat4(), glm::radians(sunAngle), glm::vec3(0.0f, 0.0f, 1.0f)) * m;
starShaders.SetUniform("model", model);
star.Draw(starShaders);
}
}
colorShaders.Use();
glm::mat4 lmodel;
lmodel = glm::scale(lmodel, glm::vec3(3.0f, 3.0f, 3.0f));
lmodel = glm::translate(lmodel, glm::vec3(0.0f, 0.1f, 0.0f));
lmodel = glm::rotate(lmodel, glm::radians(30.0f), glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat3 normalMatrix = glm::mat3(glm::transpose(glm::inverse(lmodel)));
colorShaders.SetUniform("view", view);
colorShaders.SetUniform("model", lmodel);
colorShaders.SetUniform("normalMatrix", normalMatrix);
colorShaders.SetUniform("Color", glm::vec4(0.93f, 0.79f, 0.69f, 1.0f));
landscape.Draw(colorShaders, false);
domeShaders.Use();
domeShaders.SetUniform("view", view);
domeShaders.SetUniform("projection", projection);
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D, domeColor);
glActiveTexture(GL_TEXTURE8);
glBindTexture(GL_TEXTURE_2D, domeGlow);
domeShaders.SetUniform("domeColor", 7);
domeShaders.SetUniform("glow", 8);
glm::mat4 dmodel;
dmodel = glm::scale(dmodel, glm::vec3(4.0f, 4.0f, 4.0f));
domeShaders.SetUniform("model", dmodel);
domeShaders.SetUniform("sunPos", sunPos);
dome.Draw(domeShaders, false);
// cheating billboarding to make the sun and moon always face the camera
glm::mat4 sunModelView = view * sunModel;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
sunModelView[i][j] = (GLfloat)(i == j);
sunModelView = glm::scale(sunModelView, glm::vec3(0.5f, 0.5f, 0.5f));
glm::mat4 moonModelView = view * moonModel;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
moonModelView[i][j] = (GLfloat)(i == j);
moonModelView = glm::scale(moonModelView, glm::vec3(0.5f, 0.5f, 0.5f));
spriteShaders.Use();
spriteShaders.SetUniform("view", glm::mat4());
spriteShaders.SetUniform("projection", projection);
spriteShaders.SetUniform("model", sunModelView);
sun.Draw(spriteShaders);
spriteShaders.SetUniform("model", moonModelView);
moon.Draw(spriteShaders);
//xzhs
// Set texture samples
shaders.Use();
glActiveTexture(GL_TEXTURE13);
glBindTexture(GL_TEXTURE_2D, woodTexture);
glActiveTexture(GL_TEXTURE14);
glBindTexture(GL_TEXTURE_2D, rockTexture);
glActiveTexture(GL_TEXTURE15);
glBindTexture(GL_TEXTURE_2D, depthMap);
shaders.SetUniform("material.texture_diffuse1", 14);
shaders.SetUniform("material.texture_specular1", 14);
shaders.SetUniform("shadowMap", 15);
// 1. Render depth of scene to texture (from light's perspective)
// - Get light projection/view matrix.
glm::mat4 lightProjection, lightView;
glm::mat4 lightSpaceMatrix;
GLfloat near_plane = 1.0f, far_plane = 7.5f;
lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane, far_plane);
lightView = glm::lookAt(sunPos, glm::vec3(0.0f), glm::vec3(1.0));
lightSpaceMatrix = lightProjection * lightView;
// - now render scene from light's point of view
simpleDepthShader.Use();
simpleDepthShader.SetUniform("lightSpaceMatrix", lightSpaceMatrix);
glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
glClear(GL_DEPTH_BUFFER_BIT);
RenderFloor(simpleDepthShader);
RenderCubes(simpleDepthShader);
glm::mat4 nmodel;
nmodel = glm::translate(nmodel, glm::vec3(0.1f, 0.3f, -0.5f));
nmodel = glm::rotate(nmodel, glm::radians(70.0f), glm::vec3(0.0f, 1.0f, 0.0f));
nmodel = glm::scale(nmodel, glm::vec3(0.05f, 0.05f, 0.05f));
simpleDepthShader.SetUniform("model", nmodel);
ourModel.Draw(simpleDepthShader);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// 2. Render scene as normal
glViewport(0, 0, windowWidth, windowHeight);
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaders.Use();
shaders.SetUniform("projection", projection);
shaders.SetUniform("view", view);
shaders.SetUniform("ViewPos", camera.Position);
// Set light uniforms
// PointLight sunPointLight(sunPos, glm::vec3(0.02f, 0.02f, 0.02f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.5f, 0.5f, 0.5f));
// sunPointLight.SetUniforms(shaders, "pointLights[0]");
// shaders.SetUniform("pointLightCount", 0);
dirLight.SetUniforms(shaders, "dirLight");
shaders.SetUniform("pointLightCount", 0);
shaders.SetUniform("lightSpaceMatrix", lightSpaceMatrix);
shaders.SetUniform("material.texture_diffuse1", 14);
shaders.SetUniform("material.texture_specular1", 14);
shaders.SetUniform("shadowMap", 15);
RenderFloor(shaders);
shaders.SetUniform("material.texture_diffuse1", 13);
shaders.SetUniform("material.texture_specular1", 13);
RenderCubes(shaders);
shaders.SetUniform("model", nmodel);
ourModel.Draw(shaders);
//xzhe
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
void makeFastFace(TileSpec tile, u8 li0, u8 li1, u8 li2, u8 li3, v3f p,
v3s16 dir, v3f scale, v3f posRelative_f,
core::array<FastFace> &dest)
{
FastFace face;
// Position is at the center of the cube.
v3f pos = p * BS;
posRelative_f *= BS;
v3f vertex_pos[4];
v3s16 vertex_dirs[4];
getNodeVertexDirs(dir, vertex_dirs);
for(u16 i=0; i<4; i++)
{
vertex_pos[i] = v3f(
BS/2*vertex_dirs[i].X,
BS/2*vertex_dirs[i].Y,
BS/2*vertex_dirs[i].Z
);
}
for(u16 i=0; i<4; i++)
{
vertex_pos[i].X *= scale.X;
vertex_pos[i].Y *= scale.Y;
vertex_pos[i].Z *= scale.Z;
vertex_pos[i] += pos + posRelative_f;
}
f32 abs_scale = 1.;
if (scale.X < 0.999 || scale.X > 1.001) abs_scale = scale.X;
else if(scale.Y < 0.999 || scale.Y > 1.001) abs_scale = scale.Y;
else if(scale.Z < 0.999 || scale.Z > 1.001) abs_scale = scale.Z;
v3f zerovector = v3f(0,0,0);
u8 alpha = tile.alpha;
/*u8 alpha = 255;
if(tile.id == TILE_WATER)
alpha = WATER_ALPHA;*/
float x0 = tile.texture.pos.X;
float y0 = tile.texture.pos.Y;
float w = tile.texture.size.X;
float h = tile.texture.size.Y;
/*video::SColor c = lightColor(alpha, li);
face.vertices[0] = video::S3DVertex(vertex_pos[0], v3f(0,1,0), c,
core::vector2d<f32>(x0+w*abs_scale, y0+h));
face.vertices[1] = video::S3DVertex(vertex_pos[1], v3f(0,1,0), c,
core::vector2d<f32>(x0, y0+h));
face.vertices[2] = video::S3DVertex(vertex_pos[2], v3f(0,1,0), c,
core::vector2d<f32>(x0, y0));
face.vertices[3] = video::S3DVertex(vertex_pos[3], v3f(0,1,0), c,
core::vector2d<f32>(x0+w*abs_scale, y0));*/
face.vertices[0] = video::S3DVertex(vertex_pos[0], v3f(0,1,0),
lightColor(alpha, li0),
core::vector2d<f32>(x0+w*abs_scale, y0+h));
face.vertices[1] = video::S3DVertex(vertex_pos[1], v3f(0,1,0),
lightColor(alpha, li1),
core::vector2d<f32>(x0, y0+h));
face.vertices[2] = video::S3DVertex(vertex_pos[2], v3f(0,1,0),
lightColor(alpha, li2),
core::vector2d<f32>(x0, y0));
face.vertices[3] = video::S3DVertex(vertex_pos[3], v3f(0,1,0),
lightColor(alpha, li3),
core::vector2d<f32>(x0+w*abs_scale, y0));
face.tile = tile;
//DEBUG
//f->tile = TILE_STONE;
dest.push_back(face);
}
int main()
{
sf::ContextSettings settings;
settings.depthBits = 24;
settings.stencilBits = 8;
sf::RenderWindow window(sf::VideoMode(800, 600, 32), ":]", sf::Style::Titlebar | sf::Style::Close, settings);
window.setKeyRepeatEnabled(true);
sf::Clock clock;
sf::Time updateTime;
std::size_t updateNumFrames;
GLuint shaderProgram = loadShaders("vertex.vert", "fragment.frag");
GLuint shaderProgramLamp = loadShaders("vertexLamp.vert", "fragmentLamp.frag");
GLuint indices[] = {
0, 1, 3,
1, 2, 3,
};
GLfloat vertices[] = {
// Positions // Normals // Texture Coords
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f
};
glm::vec3 cubePositions[] = {
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3( 2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3( 1.3f, -2.0f, -2.5f),
glm::vec3( 1.5f, 2.0f, -2.5f),
glm::vec3( 1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
glm::vec3 pointLightPositions[] = {
glm::vec3( 2.7f, 0.2f, 2.0f),
glm::vec3( 2.3f, -3.3f, -4.0f),
glm::vec3(-4.0f, 2.0f, -7.0f),
glm::vec3( 1.5f, 0.0f, -6.0f)
};
GLuint vao;
glGenVertexArrays(1, &vao);
GLuint vbo;
glGenBuffers(1, &vbo);
GLuint ebo;
glGenBuffers(1, &ebo);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
//position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
//normal
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
//texcoord
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
//position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
glEnable(GL_DEPTH_TEST);
bool wireframe = true;
glm::vec3 lightPos(1.2f, 0.0f, 0.0f);
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
GLfloat cameraSpeed = 0.1f;
GLfloat yaw = -90.0f;
GLfloat pitch = 0.0f;
GLfloat lastX = 800 / 2.0;
GLfloat lastY = 600 / 2.0;
sf::Image diffuseMap;
if (!diffuseMap.loadFromFile("container2.png"))
return -1;
GLuint diffuseMapID;
GLint uniform_diffuseMap;
glGenTextures(1, &diffuseMapID);
glBindTexture(GL_TEXTURE_2D, diffuseMapID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, diffuseMap.getSize().x, diffuseMap.getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, diffuseMap.getPixelsPtr());
glGenerateMipmap(GL_TEXTURE_2D);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
sf::Image specularMap;
if (!specularMap.loadFromFile("container2_specular.png"))
return -1;
GLuint specularMapID;
GLint uniform_specularMap;
glGenTextures(1, &specularMapID);
glBindTexture(GL_TEXTURE_2D, specularMapID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, specularMap.getSize().x, specularMap.getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, specularMap.getPixelsPtr());
glGenerateMipmap(GL_TEXTURE_2D);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
bool firstMouse = true;
auto t_start = std::chrono::high_resolution_clock::now();
const sf::Vector2i windowCenter( 400, 300 );
while (window.isOpen())
{
sf::Time elapsed = clock.restart();
float dt = elapsed.asSeconds();
updateTime += elapsed;
updateNumFrames += 1;
if(updateTime >= sf::seconds(1.0f))
{
std::cout << "FPS: " << updateNumFrames << std::endl;
updateTime -= sf::seconds(1.0f);
updateNumFrames = 0;
}
sf::Event event;
while (window.pollEvent(event))
{
switch (event.type)
{
case sf::Event::Closed:
window.close();
break;
case sf::Event::KeyPressed:
{
if(event.key.code == sf::Keyboard::Escape)
window.close();
if(event.key.code == sf::Keyboard::E)
{
if(wireframe) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
wireframe = false;
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
wireframe = true;
}
}
if(event.key.code == sf::Keyboard::F)
lightPos.y += 0.1;
if(event.key.code == sf::Keyboard::R)
lightPos.y -= 0.1;
}
}
}
auto t_now = std::chrono::high_resolution_clock::now();
float time = std::chrono::duration_cast<std::chrono::duration<float>>(t_now - t_start).count();
sf::Vector2f windowSize = static_cast<sf::Vector2f>(window.getSize());
sf::Vector2i mousePosition = sf::Mouse::getPosition(window);
float xpos = mousePosition.x;
float ypos = mousePosition.y;
if(firstMouse)
{
lastX = xpos;
lastY = ypos;
firstMouse = false;
}
GLfloat xoffset = xpos - lastX;
GLfloat yoffset = lastY - ypos;
lastX = xpos;
lastY = ypos;
GLfloat sensitivity = 0.1;
xoffset *= sensitivity;
yoffset *= sensitivity;
yaw += xoffset;
pitch += yoffset;
if(pitch > 89.0f)
pitch = 89.0f;
if(pitch < -89.0f)
pitch = -89.0f;
glm::vec3 front;
front.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
front.y = sin(glm::radians(pitch));
front.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
cameraFront = glm::normalize(front);
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W) || sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
cameraPos += 2.0f * dt * cameraFront;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::S) || sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
cameraPos -= 2.0f * dt * cameraFront;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A) || sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
cameraPos -= 2.0f * dt * glm::normalize(glm::cross(cameraFront, cameraUp));
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D) || sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
cameraPos += 2.0f * dt * glm::normalize(glm::cross(cameraFront, cameraUp));
}
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//camera + cubes shader
glUseProgram(shaderProgram);
GLint viewPosLoc = glGetUniformLocation(shaderProgram, "viewPos");
glUniform3f(viewPosLoc, cameraPos.x, cameraPos.y, cameraPos.z);
float moveX = sin(time) * 0.8f;
float moveY = cos(time ) * 0.8f;
glUniform1f(glGetUniformLocation(shaderProgram, "material.shininess"), 32.0f);
// == ==========================
// Here we set all the uniforms for the 5/6 types of lights we have. We have to set them manually and index
// the proper PointLight struct in the array to set each uniform variable. This can be done more code-friendly
// by defining light types as classes and set their values in there, or by using a more efficient uniform approach
// by using 'Uniform buffer objects', but that is something we discuss in the 'Advanced GLSL' tutorial.
// == ==========================
// Directional light
glUniform3f(glGetUniformLocation(shaderProgram, "dirLight.direction"), -0.2f, -1.0f, -0.3f);
glUniform3f(glGetUniformLocation(shaderProgram, "dirLight.ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shaderProgram, "dirLight.diffuse"), 0.4f, 0.4f, 0.4f);
glUniform3f(glGetUniformLocation(shaderProgram, "dirLight.specular"), 0.5f, 0.5f, 0.5f);
// Point light 1
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[0].position"), pointLightPositions[0].x * moveX, pointLightPositions[0].y, pointLightPositions[0].z * moveY);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[0].diffuse"), 0.8f, 0.8f, 0.8f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[0].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[0].linear"), 0.09);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[0].quadratic"), 0.032);
// Point light 2
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[1].position"), pointLightPositions[1].x * moveX, pointLightPositions[1].y, pointLightPositions[1].z * moveY);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[1].diffuse"), 0.8f, 0.8f, 0.8f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[1].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[1].linear"), 0.09);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[1].quadratic"), 0.032);
// Point light 3
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[2].position"), pointLightPositions[2].x * moveX, pointLightPositions[2].y, pointLightPositions[2].z * moveY);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[2].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[2].diffuse"), 0.8f, 0.8f, 0.8f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[2].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[2].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[2].linear"), 0.09);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[2].quadratic"), 0.032);
// Point light 4
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[3].position"), pointLightPositions[3].x * moveX, pointLightPositions[3].y, pointLightPositions[3].z * moveY);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[3].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[3].diffuse"), 0.8f, 0.8f, 0.8f);
glUniform3f(glGetUniformLocation(shaderProgram, "pointLights[3].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[3].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[3].linear"), 0.09);
glUniform1f(glGetUniformLocation(shaderProgram, "pointLights[3].quadratic"), 0.032);
glActiveTexture(GL_TEXTURE0);
glUniform1i(uniform_diffuseMap, GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMapID);
glActiveTexture(GL_TEXTURE1);
glUniform1i(uniform_specularMap, GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMapID);
glm::mat4 view;
glm::mat4 projection;
view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
projection = glm::perspective(45.0f, 800.0f/600.0f, 0.1f, 100.0f);
GLint modelLoc = glGetUniformLocation(shaderProgram, "model");
GLint viewLoc = glGetUniformLocation(shaderProgram, "view");
GLint projLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glm::mat4 model;
glBindVertexArray(vao);
for (GLuint i = 0; i < 10; ++i)
{
model = glm::mat4();
model = glm::translate(model, cubePositions[i]);
model = glm::rotate(model, 20.0f * i, glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
//LAMP shader
glUseProgram(shaderProgramLamp);
// Get location objects for the matrices on the lamp shader (these could be different on a different shader)
modelLoc = glGetUniformLocation(shaderProgramLamp, "model");
viewLoc = glGetUniformLocation(shaderProgramLamp, "view");
projLoc = glGetUniformLocation(shaderProgramLamp, "projection");
// Set matrices
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
// We now draw as many light bulbs as we have point lights.
glBindVertexArray(lightVAO);
for (GLuint i = 0; i < 4; i++)
{
model = glm::mat4();
model = glm::translate(model, glm::vec3(pointLightPositions[i].x * moveX, pointLightPositions[i].y, pointLightPositions[i].z * moveY));
model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
window.display();
}
glDeleteProgram(shaderProgram);
glDeleteBuffers(1, &vbo);
}
int main(int argc, const char * argv[]) {
CommonSettings Settings;
GLFWwindow *window = Settings.CreateWindow();
if (nullptr == window) {
std::cout << "Create window failed." << std::endl;
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
GLfloat vertices[] = {
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
};
GLuint VAO, VBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
#ifdef __APPLE__
string path = "/Basic Lighting/2/";
#else
string path = "\\Basic Lighting\\2\\";
#endif
ShaderReader shader(Settings.CCExercisesPath(path + "EX_L_BL_2.vs").c_str(), Settings.CCExercisesPath(path + "EX_L_BL_2.fs").c_str());
ShaderReader lightShader(Settings.CCExercisesPath(path + "EX_L_BL_2_light.vs").c_str(), Settings.CCExercisesPath(path + "EX_L_BL_2_light.fs").c_str());
glm::mat4 modelMat;
glm::mat4 viewMat;
glm::mat4 projMat;
GLint width, height;
glfwGetFramebufferSize(window, &width, &height);
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
glm::vec3 objectColor(1.0f, 0.5f, 0.31f);
shader.Use();
GLint modelLoc = glGetUniformLocation(shader.GetProgram(), "modelMat");
GLint viewLoc = glGetUniformLocation(shader.GetProgram(), "viewMat");
GLint projLoc = glGetUniformLocation(shader.GetProgram(), "projMat");
GLint lightColorLoc = glGetUniformLocation(shader.GetProgram(), "lightColor");
GLint objectColorLoc = glGetUniformLocation(shader.GetProgram(), "objectColor");
GLint lightPosLoc = glGetUniformLocation(shader.GetProgram(), "lightPos");
GLint viewPosLoc = glGetUniformLocation(shader.GetProgram(), "viewPos");
lightShader.Use();
GLint lightModelLoc = glGetUniformLocation(lightShader.GetProgram(), "modelMat");
GLint lightViewLoc = glGetUniformLocation(lightShader.GetProgram(), "viewMat");
GLint lightProjLoc = glGetUniformLocation(lightShader.GetProgram(), "projMat");
GLint lightLightColorLoc = glGetUniformLocation(lightShader.GetProgram(), "lightColor");
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
do_movement();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat currentTime = glfwGetTime();
deltaTime = currentTime - lastFrame;
lastFrame = currentTime;
viewMat = cam.getViewMatrix();
projMat = glm::perspective(cam.getZoom(), (GLfloat)width / height, 0.1f, 100.0f);
shader.Use();
modelMat = glm::mat4();
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMat));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(viewMat));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projMat));
glUniform3f(lightColorLoc, lightColor.x, lightColor.y, lightColor.z);
glUniform3f(objectColorLoc, objectColor.x, objectColor.y, objectColor.z);
glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z);
glUniform3f(viewPosLoc, cam.getPosition().x, cam.getPosition().y, cam.getPosition().z);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
lightShader.Use();
modelMat = glm::mat4();
modelMat = glm::translate(modelMat, glm::vec3(lightPos.x, lightPos.y, lightPos.z));
modelMat = glm::scale(modelMat, glm::vec3(0.2f));
glUniformMatrix4fv(lightModelLoc, 1, GL_FALSE, glm::value_ptr(modelMat));
glUniformMatrix4fv(lightViewLoc, 1, GL_FALSE, glm::value_ptr(viewMat));
glUniformMatrix4fv(lightProjLoc, 1, GL_FALSE, glm::value_ptr(projMat));
glUniform3f(lightLightColorLoc, lightColor.x, lightColor.y, lightColor.z);
glBindVertexArray(lightVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
void HWDrawInfo::GetDynSpriteLight(AActor *self, float x, float y, float z, FLightNode *node, int portalgroup, float *out)
{
FDynamicLight *light;
float frac, lr, lg, lb;
float radius;
out[0] = out[1] = out[2] = 0.f;
// Go through both light lists
while (node)
{
light=node->lightsource;
if (light->ShouldLightActor(self))
{
float dist;
FVector3 L;
// This is a performance critical section of code where we cannot afford to let the compiler decide whether to inline the function or not.
// This will do the calculations explicitly rather than calling one of AActor's utility functions.
if (Level->Displacements.size > 0)
{
int fromgroup = light->Sector->PortalGroup;
int togroup = portalgroup;
if (fromgroup == togroup || fromgroup == 0 || togroup == 0) goto direct;
DVector2 offset = Level->Displacements.getOffset(fromgroup, togroup);
L = FVector3(x - (float)(light->X() + offset.X), y - (float)(light->Y() + offset.Y), z - (float)light->Z());
}
else
{
direct:
L = FVector3(x - (float)light->X(), y - (float)light->Y(), z - (float)light->Z());
}
dist = (float)L.LengthSquared();
radius = light->GetRadius();
if (dist < radius * radius)
{
dist = sqrtf(dist); // only calculate the square root if we really need it.
frac = 1.0f - (dist / radius);
if (light->IsSpot())
{
L *= -1.0f / dist;
DAngle negPitch = -*light->pPitch;
DAngle Angle = light->target->Angles.Yaw;
double xyLen = negPitch.Cos();
double spotDirX = -Angle.Cos() * xyLen;
double spotDirY = -Angle.Sin() * xyLen;
double spotDirZ = -negPitch.Sin();
double cosDir = L.X * spotDirX + L.Y * spotDirY + L.Z * spotDirZ;
frac *= (float)smoothstep(light->pSpotOuterAngle->Cos(), light->pSpotInnerAngle->Cos(), cosDir);
}
if (frac > 0 && (!light->shadowmapped || screen->mShadowMap.ShadowTest(light, { x, y, z })))
{
lr = light->GetRed() / 255.0f;
lg = light->GetGreen() / 255.0f;
lb = light->GetBlue() / 255.0f;
if (light->IsSubtractive())
{
float bright = (float)FVector3(lr, lg, lb).Length();
FVector3 lightColor(lr, lg, lb);
lr = (bright - lr) * -1;
lg = (bright - lg) * -1;
lb = (bright - lb) * -1;
}
out[0] += lr * frac;
out[1] += lg * frac;
out[2] += lb * frac;
}
}
}
node = node->nextLight;
}
}
Node *
ColladaLight::createInstanceCommon(
ColladaLightInstInfo *colInstInfo, domLight::domTechnique_common *tech)
{
domLightRef light = getDOMElementAs<domLight>();
OSG_COLLADA_LOG(("ColladaLight::createInstanceCommon id [%s]\n",
light->getId()));
NodeUnrecPtr lightN = NULL;
domLight::domTechnique_common::domAmbientRef ambient =
tech->getAmbient();
domLight::domTechnique_common::domDirectionalRef directional =
tech->getDirectional();
domLight::domTechnique_common::domPointRef point =
tech->getPoint();
domLight::domTechnique_common::domSpotRef spot =
tech->getSpot();
if(ambient != NULL)
{
Color4f lightColor(ambient->getColor()->getValue()[0],
ambient->getColor()->getValue()[1],
ambient->getColor()->getValue()[2], 1.f);
LightLoaderState *state =
getGlobal()->getLoaderStateAs<LightLoaderState>(_loaderStateName);
OSG_ASSERT(state != NULL);
LightModelChunkUnrecPtr lmChunk = state->getLightModelChunk();
if(state->getLightModelChunk() == NULL)
{
lmChunk = LightModelChunk::create();
lmChunk->setAmbient(Color4f(0.f, 0.f, 0.f, 1.f));
state->setLightModelChunk(lmChunk);
// only place one instance into the inst queue, it will
// add the LightModelChunk with the accumulated ambient
// for the scene
ColladaInstInfoRefPtr ambientInstInfo =
ColladaLightAmbientInstInfo::create(
colInstInfo->getColInstParent(),
dynamic_cast<ColladaInstanceLight *>(
colInstInfo->getColInst()) );
getGlobal()->editInstQueue().push_back(ambientInstInfo);
}
lightColor[0] =
osgClamp(0.f, lmChunk->getAmbient()[0] + lightColor[0], 1.f);
lightColor[1] =
osgClamp(0.f, lmChunk->getAmbient()[1] + lightColor[1], 1.f);
lightColor[2] =
osgClamp(0.f, lmChunk->getAmbient()[2] + lightColor[0], 1.f);
lmChunk->setAmbient(lightColor);
}
if(directional != NULL)
{
Color4f lightColor(directional->getColor()->getValue()[0],
directional->getColor()->getValue()[1],
directional->getColor()->getValue()[2], 1.f);
DirectionalLightUnrecPtr dl = DirectionalLight::create();
lightN = makeNodeFor(dl);
dl->setBeacon (colInstInfo->getBeacon());
dl->setDiffuse (lightColor );
dl->setSpecular(lightColor );
}
if(point != NULL)
{
Color4f lightColor(point->getColor()->getValue()[0],
point->getColor()->getValue()[1],
point->getColor()->getValue()[2], 1.f);
PointLightUnrecPtr pl = PointLight::create();
lightN = makeNodeFor(pl);
Real32 constAtt = 1.f;
Real32 linAtt = 0.f;
Real32 quadAtt = 0.f;
if(point->getConstant_attenuation() != NULL)
constAtt = point->getConstant_attenuation()->getValue();
if(point->getLinear_attenuation() != NULL)
linAtt = point->getLinear_attenuation()->getValue();
if(point->getQuadratic_attenuation() != NULL)
quadAtt = point->getQuadratic_attenuation()->getValue();
pl->setBeacon (colInstInfo->getBeacon());
pl->setDiffuse (lightColor );
pl->setSpecular (lightColor );
pl->setConstantAttenuation (constAtt );
pl->setLinearAttenuation (linAtt );
pl->setQuadraticAttenuation(quadAtt );
}
if(spot != NULL)
{
Color4f lightColor(spot->getColor()->getValue()[0],
spot->getColor()->getValue()[1],
spot->getColor()->getValue()[2], 1.f);
SpotLightUnrecPtr sl = SpotLight::create();
lightN = makeNodeFor(sl);
Real32 constAtt = 1.f;
Real32 linAtt = 0.f;
Real32 quadAtt = 0.f;
Real32 cutOff = 180.f;
Real32 exponent = 0.f;
if(spot->getConstant_attenuation() != NULL)
constAtt = spot->getConstant_attenuation()->getValue();
if(spot->getLinear_attenuation() != NULL)
linAtt = spot->getLinear_attenuation()->getValue();
if(spot->getQuadratic_attenuation() != NULL)
quadAtt = spot->getQuadratic_attenuation()->getValue();
if(spot->getFalloff_angle() != NULL)
cutOff = spot->getFalloff_angle()->getValue();
if(spot->getFalloff_exponent() != NULL)
exponent = spot->getFalloff_exponent()->getValue();
sl->setBeacon (colInstInfo->getBeacon());
sl->setDiffuse (lightColor );
sl->setSpecular (lightColor );
sl->setConstantAttenuation (constAtt );
sl->setLinearAttenuation (linAtt );
sl->setQuadraticAttenuation(quadAtt );
sl->setSpotCutOff (osgDegree2Rad(cutOff) );
sl->setSpotExponent (exponent );
}
if(lightN != NULL)
{
editInstStore().push_back(lightN);
if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
light->getName() != NULL )
{
setName(lightN, light->getName());
}
}
return lightN;
}
BOOL Setup()
{
HRESULT hr;
hr = g_pDevice->CreateVertexBuffer(sizeof(Vertex)* 24,
0,
Vertex::FVF,
D3DPOOL_MANAGED,
&g_pVertexBuffer,
NULL);
if (FAILED(hr))
{
MessageBox(NULL, _T("创建顶点缓存失败！"), NULL, MB_OK);
return FALSE;
}
Vertex * pVertexs;
g_pVertexBuffer->Lock(0, 0, reinterpret_cast<void**>(&pVertexs), 0);
// floor
pVertexs[0] = Vertex(-7.5f, 0.0f, -10.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f);
pVertexs[1] = Vertex(-7.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);
pVertexs[2] = Vertex(7.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
pVertexs[3] = Vertex(-7.5f, 0.0f, -10.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f);
pVertexs[4] = Vertex(7.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
pVertexs[5] = Vertex(7.5f, 0.0f, -10.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f);
// wall
pVertexs[6] = Vertex(-7.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
pVertexs[7] = Vertex(-7.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
pVertexs[8] = Vertex(-2.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
pVertexs[9] = Vertex(-7.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
pVertexs[10] = Vertex(-2.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
pVertexs[11] = Vertex(-2.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);
// Note: We leave gap in middle of walls for mirror
pVertexs[12] = Vertex(2.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
pVertexs[13] = Vertex(2.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
pVertexs[14] = Vertex(7.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
pVertexs[15] = Vertex(2.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
pVertexs[16] = Vertex(7.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
pVertexs[17] = Vertex(7.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);
// mirror
pVertexs[18] = Vertex(-2.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
pVertexs[19] = Vertex(-2.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
pVertexs[20] = Vertex(2.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
pVertexs[21] = Vertex(-2.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
pVertexs[22] = Vertex(2.5f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
pVertexs[23] = Vertex(2.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);
g_pVertexBuffer->Unlock();
g_materialWall.Ambient = D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 255));
g_materialWall.Diffuse = D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 255));
g_materialWall.Specular = D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 255));
g_materialWall.Emissive = D3DXCOLOR(D3DCOLOR_XRGB(0, 0, 0));
g_materialWall.Power = 2.f;
g_materialFloor = g_materialWall;
g_materialMirror = g_materialWall;
g_materialWall.Specular = 0.2f *D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 255));
g_materalTeapot.Ambient = D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 0));
g_materalTeapot.Diffuse = D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 0));
g_materalTeapot.Specular = D3DXCOLOR(D3DCOLOR_XRGB(255, 255, 0));
g_materalTeapot.Emissive = D3DXCOLOR(D3DCOLOR_XRGB(0, 0, 0));
g_materalTeapot.Power = 2.f;
//创建纹理
D3DXCreateTextureFromFile(g_pDevice,
_T("brick0.jpg"),
&g_pTextureWall);
D3DXCreateTextureFromFile(g_pDevice,
_T("checker.jpg"),
&g_pTextureFloor);
D3DXCreateTextureFromFile(g_pDevice,
_T("ice.bmp"),
&g_pTextureMirror);
g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
g_pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
D3DXCreateTeapot(g_pDevice, &g_pMeshTeapot, 0);
//设置方向光
D3DLIGHT9 light;
D3DXCOLOR lightColor(1.0f, 1.0f, 1.0f,1.0f);
memset(&light, 0, sizeof(light));
light.Type = D3DLIGHT_DIRECTIONAL;
light.Ambient = lightColor* 0.4f;
light.Diffuse = lightColor;
light.Specular = lightColor * 0.6f;
light.Direction = D3DXVECTOR3(0.707f, -0.707f, 0.707);
g_pDevice->SetLight(0, &light);
g_pDevice->LightEnable(0, TRUE);
g_pDevice->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
g_pDevice->SetRenderState(D3DRS_SPECULARENABLE, TRUE);
//设置摄像机
D3DXVECTOR3 pos(-10.0f, 3.0f, -15.0f);
D3DXVECTOR3 target(0.0, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX V;
D3DXMatrixLookAtLH(&V, &pos, &target, &up);
g_pDevice->SetTransform(D3DTS_VIEW, &V);
//
// Set projection matrix.
//
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI / 4.0f, // 45 - degree
(float)g_cxWindow / (float)g_cyWindow,
1.0f,
1000.0f);
g_pDevice->SetTransform(D3DTS_PROJECTION, &proj);
return TRUE;
}
void Light::paint(QPainter *p, const QRectF& boundingRect, const QPointF& mousePos, bool mouseIn, const bool isRotated) {
if (!mouseIn && !m_animation) {
return;
}
QRectF drawRect(boundingRect);
// XXX: ugly hack because I don't know the real contents area of the FrameSvg
drawRect.adjust(-4, -4, +4, +4);
qreal width = drawRect.width();
qreal height = drawRect.height();
qreal size = 0.5;
qreal x;
qreal y;
QColor lightColor(m_item->icon()->highlightColor());
switch (m_currentAnimation) {
case StartupAnimation:
case AttentionAnimation:
x = drawRect.left() + width * 0.5;
y = drawRect.top() + height * 0.5;
size = size * 2.0 *
(m_progress < 0.5 ? (m_progress * 0.5 + 0.5) : (1 - m_progress / 2));
break;
case NoAnimation:
if (isRotated) {
x = m_item->size().height() - mousePos.y();
y = mousePos.x();
}
else {
x = mousePos.x();
y = mousePos.y();
}
// y = drawRect.top() + height * 1.10;
width *= 2.0;
height *= 2.0;
break;
default:
return;
}
QRadialGradient gradient(0.5, 0.5, size);
gradient.setCoordinateMode(QRadialGradient::ObjectBoundingMode);
lightColor.setAlpha(200);
gradient.setColorAt(0.0, lightColor);
lightColor.setAlpha(60);
gradient.setColorAt(0.6, lightColor);
lightColor.setAlpha(0);
gradient.setColorAt(1.0, lightColor);
p->setClipRect(drawRect);
p->fillRect(
x - width * 0.5,
y - height * 0.5,
width, height,
gradient);
p->setClipping(false);
}
int main() {
// Initialize GLFW and set some hints that will create an OpenGL 3.3 context
// using core profile.
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create a fixed 800x600 window that is not resizable.
GLFWwindow* window = glfwCreateWindow(kWindowWidth, kWindowHeight, "LearnGL", nullptr, nullptr);
if (window == nullptr) {
std::cerr << "Failed to created GLFW window" << std::endl;
glfwTerminate();
return 1;
}
// Create an OpenGL context and pass callbacks to GLFW.
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, keyCallback);
glfwSetCursorPosCallback(window, mouseCallback);
glfwSetScrollCallback(window, scrollCallback);
// Lock the mouse in the window.
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) {
std::cerr << "Failed to initialize GLEW" << std::endl;
glfwTerminate();
return 1;
}
// Create a viewport the same size as the window. glfwGetFramebufferSize is
// used rather than the size constants since some windowing systems have a
// discrepancy between window size and framebuffer size
// (e.g HiDPi screen coordinates),
int fbWidth, fbHeight;
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
glViewport(0, 0, fbWidth, fbHeight);
// Enable use of the depth buffer since we're working on 3D and want to
// prevent overlapping polygon artifacts.
glEnable(GL_DEPTH_TEST);
// Read and compile the vertex and fragment shaders using
// the shader helper class.
Shader shader("glsl/vertex.glsl", "glsl/fragment.glsl");
Shader lampShader("glsl/lampvertex.glsl", "glsl/lampfragment.glsl");
Model crysisModel("assets/nanosuit.obj");
GLuint containerTexture = loadTexture("assets/container2.png");
GLuint containerSpecular = loadTexture("assets/container2_specular.png");
GLuint containerEmission = loadTexture("assets/matrix.jpg");
// Container mesh data.
GLfloat vertices[] = {
// Vertices // Normals // UVs
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f
};
// Positions all containers
glm::vec3 cubePositions[] = {
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3( 2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3( 1.3f, -2.0f, -2.5f),
glm::vec3( 1.5f, 2.0f, -2.5f),
glm::vec3( 1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
// Create a VBO to store the vertex data, an EBO to store indice data, and
// create a VAO to retain our vertex attribute pointers.
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
// Fill the VBO and set vertex attributes.
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
// Create a lamp box thing using the existing container VBO.
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
// Use the container's VBO and set vertex attributes.
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
// Create a perspective camera to fit the viewport.
screenWidth = (GLfloat)fbWidth;
screenHeight = (GLfloat)fbHeight;
camera = PerspectiveCamera(
glm::vec3(0.0f, 0.0f, 3.0f),
glm::vec3(0.0f, glm::radians(-90.0f), 0.0f),
glm::radians(45.0f),
screenWidth / screenHeight,
0.1f,
100.0f
);
GLfloat delta = 0.0f;
GLfloat lastFrame = 0.0f;
// Light information.
const glm::vec3 directionalLightDir(0.0f, 1.0f, 0.0f);
const glm::vec3 pointLightPositions[] = {
glm::vec3( 0.7f, 0.2f, 2.0f),
glm::vec3( 2.3f, -3.3f, -4.0f),
glm::vec3(-4.0f, 2.0f, -12.0f),
glm::vec3( 0.0f, 0.0f, -3.0f)
};
// Render loop.
while (!glfwWindowShouldClose(window)) {
GLfloat currentFrame = glfwGetTime();
delta = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events.
glfwPollEvents();
move(delta);
// Clear the screen to a nice blue color.
glClearColor(0.1f, 0.15f, 0.15f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
const GLfloat limitTime = 1.0f;
fovTime += delta;
if (fovTime > limitTime) {
fovTime = limitTime;
}
// Update the perspective to account for changes in fov.
camera.fov = easeOutQuart(fovTime, startFov, (startFov - targetFov) * -1, limitTime);
camera.update();
shader.use();
// Pass the view and projection matrices from the camera.
GLuint viewMatrix = glGetUniformLocation(shader.program, "view");
glUniformMatrix4fv(viewMatrix, 1, GL_FALSE, glm::value_ptr(camera.view));
GLuint projectionMatrix = glGetUniformLocation(shader.program, "projection");
glUniformMatrix4fv(projectionMatrix, 1, GL_FALSE, glm::value_ptr(camera.projection));
// Generate light colors.
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
// Directional light
glUniform3f(glGetUniformLocation(shader.program, "dirLight.direction"), -0.2f, -1.0f, -0.3f);
glUniform3f(glGetUniformLocation(shader.program, "dirLight.ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "dirLight.diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "dirLight.specular"), 1.0f, 1.0f, 1.0f);
// Point light 1
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].position"), pointLightPositions[0].x, pointLightPositions[0].y, pointLightPositions[0].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].quadratic"), 0.032);
// Point light 2
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].position"), pointLightPositions[1].x, pointLightPositions[1].y, pointLightPositions[1].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].quadratic"), 0.032);
// Point light 3
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].position"), pointLightPositions[2].x, pointLightPositions[2].y, pointLightPositions[2].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[2].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[2].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[2].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[2].quadratic"), 0.032);
// Point light 4
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].position"), pointLightPositions[3].x, pointLightPositions[3].y, pointLightPositions[3].z);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].ambient"), 0.05f, 0.05f, 0.05f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "pointLights[3].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[3].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[3].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "pointLights[3].quadratic"), 0.032);
// Sport light 1
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].position"), camera.position.x, camera.position.y, camera.position.z);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].direction"), camera.front.x, camera.front.y, camera.front.z);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].ambient"), 0.0f, 0.0f, 0.0f);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(shader.program, "spotLights[0].specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].constant"), 1.0f);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].linear"), 0.09);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].quadratic"), 0.032);
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].cutoff"), glm::cos(glm::radians(12.5f)));
glUniform1f(glGetUniformLocation(shader.program, "spotLights[0].outerCutoff"), glm::cos(glm::radians(15.5f)));
// Pass material values.
GLuint materialShininess = glGetUniformLocation(shader.program, "material.shininess");
GLuint materialDiffuse = glGetUniformLocation(shader.program, "material.diffuse");
GLuint materialSpecular = glGetUniformLocation(shader.program, "material.specular");
GLuint materialEmission = glGetUniformLocation(shader.program, "material.emission");
glUniform1f(materialShininess, 64.0f);
glUniform1i(materialDiffuse, 0);
glUniform1i(materialSpecular, 1);
glUniform1i(materialEmission, 2);
// Misc values.
GLuint viewPos = glGetUniformLocation(shader.program, "viewPos");
glUniform3f(viewPos, camera.position.x, camera.position.y, camera.position.z);
// Bind the textures.
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, containerTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, containerSpecular);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, containerEmission);
// Apply world transformations.
model = glm::mat4();
GLuint modelMatrix = glGetUniformLocation(shader.program, "model");
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
// Calculate the normal matrix on the CPU (keep them normals perpendicular).
normal = glm::mat3(glm::transpose(glm::inverse(model)));
GLuint normalMatrix = glGetUniformLocation(shader.program, "normalMatrix");
glUniformMatrix3fv(normalMatrix, 1, GL_FALSE, glm::value_ptr(normal));
// Draw the magic man!
crysisModel.draw(shader);
// Bind the VAO and shader.
glBindVertexArray(lightVAO);
lampShader.use();
// Pass the view and projection matrices from the camera.
viewMatrix = glGetUniformLocation(lampShader.program, "view");
glUniformMatrix4fv(viewMatrix, 1, GL_FALSE, glm::value_ptr(camera.view));
projectionMatrix = glGetUniformLocation(lampShader.program, "projection");
glUniformMatrix4fv(projectionMatrix, 1, GL_FALSE, glm::value_ptr(camera.projection));
for (GLuint i = 0; i < 4; i++) {
// Apply world transformations.
model = glm::mat4();
model = glm::translate(model, pointLightPositions[i]);
model = glm::scale(model, glm::vec3(0.2f));
modelMatrix = glGetUniformLocation(lampShader.program, "model");
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
// Draw the lamp.
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Swap buffers used for double buffering.
glfwSwapBuffers(window);
}
// Properly deallocate the VBO and VAO.
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
// Terminate GLFW and clean any resources before exiting.
glfwTerminate();
return 0;
}
void gl_SetDynSpriteLight(AActor *self, float x, float y, float z, subsector_t * subsec)
{
ADynamicLight *light;
float frac, lr, lg, lb;
float radius;
float out[3] = { 0.0f, 0.0f, 0.0f };
// Go through both light lists
FLightNode * node = subsec->lighthead;
while (node)
{
light=node->lightsource;
if (light->visibletoplayer && !(light->flags2&MF2_DORMANT) && (!(light->lightflags&LF_DONTLIGHTSELF) || light->target != self) && !(light->lightflags&LF_DONTLIGHTACTORS))
{
float dist;
// This is a performance critical section of code where we cannot afford to let the compiler decide whether to inline the function or not.
// This will do the calculations explicitly rather than calling one of AActor's utility functions.
if (Displacements.size > 0)
{
int fromgroup = light->Sector->PortalGroup;
int togroup = subsec->sector->PortalGroup;
if (fromgroup == togroup || fromgroup == 0 || togroup == 0) goto direct;
DVector2 offset = Displacements.getOffset(fromgroup, togroup);
dist = FVector3(x - light->X() - offset.X, y - light->Y() - offset.Y, z - light->Z()).LengthSquared();
}
else
{
direct:
dist = FVector3(x - light->X(), y - light->Y(), z - light->Z()).LengthSquared();
}
radius = light->GetRadius();
if (dist < radius * radius)
{
dist = sqrtf(dist); // only calculate the square root if we really need it.
frac = 1.0f - (dist / radius);
if (frac > 0 && GLRenderer->mShadowMap.ShadowTest(light, { x, y, z }))
{
lr = light->GetRed() / 255.0f;
lg = light->GetGreen() / 255.0f;
lb = light->GetBlue() / 255.0f;
if (light->IsSubtractive())
{
float bright = FVector3(lr, lg, lb).Length();
FVector3 lightColor(lr, lg, lb);
lr = (bright - lr) * -1;
lg = (bright - lg) * -1;
lb = (bright - lb) * -1;
}
out[0] += lr * frac;
out[1] += lg * frac;
out[2] += lb * frac;
}
}
}
node = node->nextLight;
}
gl_RenderState.SetDynLight(out[0], out[1], out[2]);
modellightindex = -1;
}
void RTRRadianceRenderer::execute()
{
//If kd-tree exists, free them.
if (diffusePhotonMap != nullptr)
{
delete diffusePhotonMap;
}
if (causticPhotonMap != nullptr)
{
delete causticPhotonMap;
}
std::vector<RTRRenderElement*> emissionElements;
for (auto element : elements)
{
if (element->material->emissionStrength > 0.0001)
{
//qDebug() << "Emission object!";
emissionElements.push_back(element);
}
}
/*for (int i = 0; i < 20; i++)
{
qDebug() << sampler->generateInteger(0, emissionElements.size() - 1);
}*/
//QVector<Photon*> diffusePhotons;
const int PHOTON_COUNT = 200000;
for(int i = 0; i < PHOTON_COUNT; i++)
{
auto chosenElementIndex = sampler->generateInteger(0, emissionElements.size() - 1);
auto chosenElement = emissionElements[chosenElementIndex];
/*RTRVector3D lightSource(-1.2 + sampler->generateRandomNumber(-1.0, 1.0)
, 0 + sampler->generateRandomNumber(-2.0, 2.0)
, 4.99);*/
auto emissionStrength = chosenElement->material->emissionStrength /
PHOTON_COUNT * chosenElement->triangle3D->area() * emissionElements.size();
RTRColor lightColor(emissionStrength, emissionStrength, emissionStrength);
auto lightSource = sampler->generateRandomPointInTriangle(*chosenElement->triangle3D);
RTRVector3D lightDirection;
do {
lightDirection = sampler->generateRandomDirection();
} while(lightDirection.z() > 0 || sampler->generateRandomNumber() > -lightDirection.z());
lightDirection.vectorNormalize();
renderPhoton(lightSource, lightDirection, allPhotons, chosenElement,
lightColor, false);
if (allPhotons.size() % 1000 == 0)
{
qDebug() << allPhotons.size();
}
}
int causticPhotonCount = 0;
int diffusePhotonCount = 0;
for(int i = 0; i < allPhotons.size(); i++)
{
if(allPhotons[i]->type == Photon::Type::CAUSTIC)
{
causticPhotonCount++;
}
else
{
diffusePhotonCount++;
}
}
qDebug() << "CAUSTIC " << causticPhotonCount;
qDebug() << "DIFFUSE " << diffusePhotonCount;
stlDiffusePhotons.clear();
stlDiffusePhotons = allPhotons.toStdVector();
/*while(causticPhotons.size() < 5000)
{
RTRVector3D lightSource(-1.2 + sampler->generateRandomNumber(-1.0, 1.0)
, 0 + sampler->generateRandomNumber(-2.0, 2.0)
, 4.99);
RTRVector3D lightDirection;
do {
lightDirection = sampler->generateRandomDirection();
} while(lightDirection.z() > 0);
lightDirection.vectorNormalize();
renderPhoton(lightSource, lightDirection, causticPhotons, chosenElement, true);
//qDebug() << causticPhotons.size();
if (causticPhotons.size() > 0 && causticPhotons.size() % 1000 == 0)
{
qDebug() << causticPhotons.size();
}
}*/
stlCausticPhotons.clear();
stlCausticPhotons = causticPhotons.toStdVector();
causticPhotonAdapter = new NanoFlannPhotonAdaptor(stlCausticPhotons);
diffusePhotonAdapter = new NanoFlannPhotonAdaptor(stlDiffusePhotons);
causticPhotonMap = new PhotonKdTree(3, *causticPhotonAdapter);
causticPhotonMap->buildIndex();
diffusePhotonMap = new PhotonKdTree(3, *diffusePhotonAdapter);
diffusePhotonMap->buildIndex();
//causticPhotonMap = NearestSearchKdTree<Photon*, double, 3, AccessRTRVector3D>::construct(causticPhotons.toStdVector());
//diffusePhotonMap = NearestSearchKdTree<Photon, double, 3, AccessRTRVector3D>::construct(diffusePhotons.toStdVector());
qDebug() << causticPhotons.size();
qDebug() << stlDiffusePhotons.size();
}