void Box::initTopBottomBack(){ GLuint VBO; GLuint CBO; GLuint IBO; glGenVertexArrays (1, &vertexArrayObjectFBTB); glBindVertexArray(vertexArrayObjectFBTB); vec3 v0 = vec3(-width/2, width/2, width/2); vec3 v1 = vec3(width/2, width/2, width/2); vec3 v2 = vec3(-width/2, -width/2, width/2); vec3 v3 = vec3(width/2, -width/2, width/2); vec3 v4 = vec3(-width/2, width/2, -width/2); vec3 v5 = vec3(width/2, width/2, -width/2); vec3 v6 = vec3(-width/2, -width/2, -width/2); vec3 v7 = vec3(width/2, -width/2, -width/2); vector<pntVertexData> v; vec2 t0 = vec2(0,1); vec2 t1 = vec2(1,1); vec2 t2 = vec2(0,0); vec2 t3 = vec2(1,0); vec2 t6 = vec2(0,1); vec2 t7 = vec2(1,1); vec2 t4 = vec2(0,0); vec2 t5 = vec2(1,0); v.push_back(pntVertexData(v0, normalize(vec3(-1,1,1)), t0)); v.push_back(pntVertexData(v1, normalize(vec3(1,1,1)), t1)); v.push_back(pntVertexData(v2, normalize(vec3(-1,-1,1)), t2)); v.push_back(pntVertexData(v3, normalize(vec3(1,-1,1)), t3)); v.push_back(pntVertexData(v4, normalize(vec3(-1,1,-1)), t4)); v.push_back(pntVertexData(v5, normalize(vec3(1,1,-1)), t5)); v.push_back(pntVertexData(v6, normalize(vec3(-1,-1,-1)), t6)); v.push_back(pntVertexData(v7, normalize(vec3(1,-1,-1)), t7)); /* glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(vec3), &v[0], GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(0); */ vector<vec4> c; vec4 c1 = vec4(1.0f, 0.0f, 0.0f, 1.0f); vec4 c2 = vec4(0.0f, 1.0f, 0.0f, 1.0f); vec4 c3 = vec4(0.0f, 0.0f, 1.0f, 1.0f); vec4 c4 = vec4(1.0f, 1.0f, 0.0f, 1.0f); vec4 c5 = vec4(1.0f, 0.0f, 1.0f, 1.0f); c.push_back(c1); c.push_back(c2); c.push_back(c3); c.push_back(c4); c.push_back(c5); c.push_back(c1); c.push_back(c2); c.push_back(c3); /* glGenBuffers(1, &CBO); glBindBuffer(GL_ARRAY_BUFFER, CBO); glBufferData(GL_ARRAY_BUFFER, c.size() * sizeof(vec4), &c[0], GL_STATIC_DRAW); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(2); */ vector<GLuint> indices; // front indices.push_back(0); indices.push_back(2); indices.push_back(1); indices.push_back(1); indices.push_back(2); indices.push_back(3); // back indices.push_back(6); indices.push_back(4); indices.push_back(5); indices.push_back(5); indices.push_back(7); indices.push_back(6); // top indices.push_back(1); indices.push_back(5); indices.push_back(0); indices.push_back(0); indices.push_back(5); indices.push_back(4); // bottom indices.push_back(7); indices.push_back(3); indices.push_back(6); indices.push_back(6); indices.push_back(3); indices.push_back(2); numberOfIndices = indices.size(); /* glGenBuffers(1, &IBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO); glBufferData( GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint), &indices[0], GL_STATIC_DRAW); */ glGenVertexArrays (1, &vertexArrayObjectFBTB); glBindVertexArray( vertexArrayObjectFBTB ); // finally, create the buffer to hold interleaved and bind the data to them glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); // Buffer for vertex data glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(pntVertexData), &v[0], GL_STATIC_DRAW); //Buffering vertex data glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), 0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), (const GLvoid*)sizeof(vec3) ); glEnableVertexAttribArray(1); glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), (const GLvoid*)(2 * sizeof(vec3)) ); glEnableVertexAttribArray(3); // Generate a buffer for the indices glGenBuffers(1, &IBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0] , GL_STATIC_DRAW); } // end initialize
vec3 Matrix44::transformVec3(vec3 v) { auto result = *this * vec4(v, 1.0f); return vec3(result.x, result.y, result.z); }
// Variables static const char var_dest[] = "ivec4 dest;\n"; static const char var_pattern[] = "ivec4 pattern;\n"; static const char var_pixel[] = "ivec4 pixel;\n"; static const char var_src[] = "ivec4 src;\n"; static const char var_patternst[] = "vec2 patternst;\n"; // Operations static const char op_src[] = "src = ivec4(texture2D(srctex,gl_TexCoord[0].st)*vec4(colorsizesrc)+.5);\n"; static const char op_pixel[] = "pixel = ivec4(texture2D(srctex,gl_TexCoord[0].st)*vec4(colorsizedest)+.5);\n"; static const char op_color[] = "pixel = fillcolor;\n"; static const char op_dest[] = "dest = ivec4(texture2D(desttex,gl_TexCoord[1].st)*vec4(colorsizedest)+.5);\n"; static const char op_pattern[] = "patternst = vec2(mod(gl_FragCoord.x,float(patternsize.x))/float(patternsize.x),\n\ mod(gl_FragCoord.y, float(patternsize.y)) / float(patternsize.y));\n\ pattern = ivec4(texture2D(patterntex,patternst)*vec4(colorsizedest)+.5);\n"; static const char op_destout[] = "gl_FragColor = vec4(pixel)/vec4(colorsizedest);\n"; static const char op_vertex[] = "vec4 xyzw = vec4(xy[0],xy[1],0,1);\n\ mat4 proj = mat4(\n\ vec4(2.0 / (view[1] - view[0]), 0, 0, 0),\n\ vec4(0, 2.0 / (view[2] - view[3]), 0, 0),\n\ vec4(0, 0, -2.0, 0),\n\ vec4(-(view[1] + view[0]) / (view[1] - view[0]),\n\ -(view[2] + view[3]) / (view[2] - view[3]), -1 , 1));\n\ gl_Position = proj * xyzw;\n"; static const char op_vertcolorrgb[] = "gl_FrontColor = vec4(rgb,1.0);\n"; static const char op_texcoord0[] = "gl_TexCoord[0] = vec4(srcst,0.0,1.0);\n"; static const char op_texcoord1[] = "gl_TexCoord[1] = vec4(destst,0.0,1.0);\n"; static const char op_texcoord3[] = "gl_TexCoord[3] = vec4(stencilst,0.0,1.0);\n"; static const char op_ckeysrc[] = "if(src.rgb == ckeysrc) discard;\n"; static const char op_ckeydest[] = "if(dest.rgb != ckeydest) discard;\n";
void main() { gl_Position = vec4(Position, 1.0f);// P*V*vec4(x, y, z, 1.0f); }
layerParam::layerParam() : position(vec2(0.f)), scale(vec2(1.f)), hsb_bias(vec3(0.f)), hsb_mod(vec3(1.f)), color_bias(vec4(0.f)), color_mod(vec4(1.f)), blend(BLEND_REPLACE) { }
void OpenglBufferData::loadBufferData() { if (!theModelView) return; SimMesh *theMesh = theModelView->theMesh; MeshColor *theColor = theModelView->theColor; MeshTexture *theTexture = theModelView->theTexture; MeshNormal *theNormals = theModelView->theNormals; vertex *data = NULL; glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); if (!theTexture) { data = new vertex[theMesh->numVertices()]; for (size_t i = 0; i < theMesh->numVertices(); i++) { data[i].position = vec4(theMesh->indVertex(i)->p[0], theMesh->indVertex(i)->p[1], theMesh->indVertex(i)->p[2], 1.0f); if (theModelView->theColor) { GLfloat a = 1.0f; if (i < theColor->a.size()) a = theColor->a[i] / 255.0f; data[i].color = vec4(theColor->r[i] / 255.0f, theColor->g[i] / 255.0f, theColor->b[i] / 255.0f, a); } else data[i].color = vec4(theModelView->color[0], theModelView->color[1], theModelView->color[2], 1.0f); } if (theNormals) { for (size_t i = 0; i < theNormals->vNormals.size(); i++) { data[i].normal = vec3(theNormals->vNormals[i][0], theNormals->vNormals[i][1], theNormals->vNormals[i][2]); } } glBufferData(GL_ARRAY_BUFFER, theMesh->numVertices() * sizeof(vertex), data, GL_STATIC_DRAW); } else { // if texture exists, we need to duplicate the vertex on each triangle data = new vertex[theMesh->numFaces() * 3]; for (size_t i = 0; i < theMesh->numFaces(); i++) { SimFace *f = theMesh->indFace(i); for (int j = 0; j < 3; j++) { SimVertex *v = f->ver[j]; data[i * 3 + j].position = vec4(theMesh->indVertex(v->idx)->p[0], theMesh->indVertex(v->idx)->p[1], theMesh->indVertex(v->idx)->p[2], 1.0); if (theNormals) { data[i * 3 + j].normal = vec3(theNormals->vNormals[v->idx][0], theNormals->vNormals[v->idx][1], theNormals->vNormals[v->idx][2]); data[i * 3 + j].tangent = vec3(theModelView->tangents[i * 3 + j][0], theModelView->tangents[i * 3 + j][1], theModelView->tangents[i * 3 + j][2]); } data[i * 3 + j].texCoord = vec2(theTexture->getU(v, f), theTexture->getV(v, f)); } } glBufferData(GL_ARRAY_BUFFER, 3 * theMesh->numFaces() * sizeof(vertex), data, GL_STATIC_DRAW); } glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vertex), BUFFER_OFFSET(0)); if (theTexture) { glEnableVertexAttribArray(3); glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(vertex), BUFFER_OFFSET(2 * sizeof(vec4) + sizeof(vec3))); if (theNormals) { glEnableVertexAttribArray(4); glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), BUFFER_OFFSET(2 * sizeof(vec4) + sizeof(vec3) + sizeof(vec2))); } } else { glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(vertex), BUFFER_OFFSET(sizeof(vec4))); } if (theNormals) { glEnableVertexAttribArray(2); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), BUFFER_OFFSET(2 * sizeof(vec4))); } unsigned int *face_indices = new unsigned int[3 * theMesh->numFaces()]; for (size_t i = 0; i < theMesh->numFaces(); i++) { SimFace *f = theMesh->indFace(i); for (int j = 0; j < 3; j++) { if (!theTexture) face_indices[3 * i + j] = f->ver[j]->idx; else face_indices[3 * i + j] = 3 * i + j; } } glGenBuffers(1, &vbo_face_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_face_indices); glBufferData(GL_ELEMENT_ARRAY_BUFFER, 3 * theMesh->numFaces() * sizeof(unsigned int), face_indices, GL_STATIC_DRAW); glGenVertexArrays(1, &vao_wireFrame); glBindVertexArray(vao_wireFrame); glBindBuffer(GL_ARRAY_BUFFER, vbo); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vertex), BUFFER_OFFSET(0)); unsigned int *edge_indices = new unsigned int[2 * theMesh->numEdges()]; if (theTexture) { for (size_t i = 0; i < theMesh->numFaces(); i++) { SimFace *f = theMesh->indFace(i); for (int j = 0; j < 3; j++) { SimEdge * e = theMesh->idEdge(f->ver[j]->idx, f->ver[(j + 1) % 3]->idx); edge_indices[2 * e->idx + 0] = i * 3 + j; edge_indices[2 * e->idx + 1] = i * 3 + (j + 1) % 3; } } } else { for (size_t i = 0; i < theMesh->numEdges(); i++) { SimEdge * e = theMesh->indEdge(i); edge_indices[2 * i + 0] = e->v0->idx; edge_indices[2 * i + 1] = e->v1->idx; } } glGenBuffers(1, &vbo_edge_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_edge_indices); glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2 * theMesh->numEdges() * sizeof(unsigned int), edge_indices, GL_STATIC_DRAW); if (theTexture) { glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); //get the OpenGL-friendly image QImage GL_formatted_image = QGLWidget::convertToGLFormat(QImage(theModelView->theTexture->texture_filename.c_str())); 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); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //generate the texture glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, GL_formatted_image.width(), GL_formatted_image.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, GL_formatted_image.bits() ); glBindTexture(GL_TEXTURE_2D, 0); //QImage GL_formatted_image2 = QGLWidget::convertToGLFormat(QImage("normal.bmp")); //glGenTextures(1, &normalTexture); //glBindTexture(GL_TEXTURE_2D, normalTexture); ////get the OpenGL-friendly image //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); //glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ////generate the texture //glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, GL_formatted_image2.width(), // GL_formatted_image2.height(), // 0, GL_RGBA, GL_UNSIGNED_BYTE, GL_formatted_image2.bits() ); //glBindTexture(GL_TEXTURE_2D, 0); } delete []data; delete []edge_indices; delete []face_indices; }
void SurfaceExtraction::updateColors() { const static vec4 defaultColor[11] = {vec4(1.0f), vec4(0x1f, 0x77, 0xb4, 255) / vec4(255, 255, 255, 255), vec4(0xff, 0x7f, 0x0e, 255) / vec4(255, 255, 255, 255), vec4(0x2c, 0xa0, 0x2c, 255) / vec4(255, 255, 255, 255), vec4(0xd6, 0x27, 0x28, 255) / vec4(255, 255, 255, 255), vec4(0x94, 0x67, 0xbd, 255) / vec4(255, 255, 255, 255), vec4(0x8c, 0x56, 0x4b, 255) / vec4(255, 255, 255, 255), vec4(0xe3, 0x77, 0xc2, 255) / vec4(255, 255, 255, 255), vec4(0x7f, 0x7f, 0x7f, 255) / vec4(255, 255, 255, 255), vec4(0xbc, 0xbd, 0x22, 255) / vec4(255, 255, 255, 255), vec4(0x17, 0xbe, 0xcf, 255) / vec4(255, 255, 255, 255)}; size_t count = 0; for (const auto& data : volume_) { count++; if (colors_.size() < count) { const static std::string color = "color"; const static std::string dispName = "Color for Volume "; FloatVec4Property* colorProp = new FloatVec4Property(color + toString(count - 1), dispName + toString(count), defaultColor[(count - 1) % 11]); colorProp->setCurrentStateAsDefault(); colorProp->setSemantics(PropertySemantics::Color); colorProp->setSerializationMode(PropertySerializationMode::ALL); colors_.addProperty(colorProp); } colors_[count - 1]->setVisible(true); } for (size_t i = count; i < colors_.size(); i++) { colors_[i]->setVisible(false); } }
int main() { Vector2<int> vec2(12,25); Vector2<int> vec3(13,24); Vector2<int> storage; std::cout << "Vector2: \n\n"; storage = vec3 + vec2; std::cout << "Add:" << "(" << storage.x << "," << storage.y << ")" << std::endl; storage = vec3 - vec2; std::cout << "Subtract:" << "(" << storage.x << "," << storage.y << ")" << std::endl; storage = vec3 / vec2; std::cout << "Divide:" << "(" << storage.x << "," << storage.y << ")" << std::endl; storage = vec3 * vec2; std::cout << "Multiply:" << "(" << storage.x << "," << storage.y << ")" << std::endl; storage = vec3 % vec2; std::cout << "Modulus:" << "(" << storage.x << "," << storage.y << "," << ")" << std::endl; int sto = storage.Dot(vec2, vec3); std::cout << "Dot product: " << sto << std::endl; int mg = storage.Mag(vec2); std::cout << "Magnitude: " << mg << std::endl; Vector2<int> norm = storage.Normalise(vec2); std::cout << "Normalize:" << "(" << norm.x << "," << norm.y << "," << ")\n\n" << std::endl; Vector3<int> vec1(12, 12, 12); Vector3<int> vec4(12, 12, 12); Vector3<int> storage2; std::cout << "Vector3: \n\n"; storage2 = vec1 + vec4; std::cout << "Add:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl; storage2 = vec1 - vec4; std::cout << "Subtract:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl; storage2 = vec1 / vec4; std::cout << "Divide:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl; storage2 = vec1 * vec4; std::cout << "Multiply:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl; storage2 = vec1 % vec4; std::cout << "Modulus:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl; int Dot = storage2.Dot(vec1, vec4); std::cout << "Dot Product is: " << Dot << std::endl; Vector3<int> cross = storage2.Cross(vec1, vec4); std::cout << "Cross Product is: " << cross.x << "," << cross.y << cross.z << std::endl; int Mag = storage2.Mag(vec1); std::cout << "Magnitude Product is: " << Mag << std::endl; Vector3<int> Norm = storage2.Normalise(vec1); std::cout << "Normalised:" << "(" << Norm.x << "," << Norm.y << "," << Norm.z << ")\n" << std::endl; std::cout << "Color: \n\n"; Color<int> color; Color<int> boo1(12, 12, 12, 12); Color<int> boo2(13, 13, 13, 13); Color<int> test; test = boo1 + boo2; std::cout << "Add:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl; test = boo1 - boo2; std::cout << "Subtract:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl; test = boo1 * boo2; std::cout << "Multiply:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl; test = boo1 / boo2; std::cout << "Quotient:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl; test = boo1 % boo2; std::cout << "Modulus:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl; test = test.Normalise(boo1); std::cout << "Normalize:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl; float mag = test.Mag(boo1); std::cout << "Magnitude: " << mag; Color<int> rgba = color.HexConv("#FFFFFF"); std::cout << "\nRGBA Values Are : (" << rgba.r << "," << rgba.g << "," << rgba.b << "," << rgba.a << ")\n"; system("PAUSE"); return 0; }
void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; gl_TexCoord[0] = gl_MultiTexCoord0; //poop cameraPosition = (gl_ModelViewMatrixInverse * vec4(0.,0.,0.,1.)).xyz; }); // END VERTEX SHADER STRINGIFY
void SSProjectiles::SetSpecificProjectileProperties( Projectile* projectile, const glm::vec3& distance ) { // TODODP: TEMP //auto GetEffect = [] ( ) -> gfx::ParticleSystem //{ // ScriptArg args[17]; // g_Script.Run( "../../../script/Test.lua" ); // g_Script.GetArray( "ParticleTest", args, 17 ); // gfx::ParticleSystem ps = g_SSParticle.GetDefaultParticleSystem( PARTICLE_TYPE_CONE ); // ps.EmitterPosition = glm::vec3( args[0].asDouble, args[1].asDouble, args[2].asDouble ); // ps.TimeToLive = args[3].asDouble; // ps.Colour = glm::vec4( args[4].asDouble, args[5].asDouble, args[6].asDouble, args[7].asDouble ); // ps.Direction = glm::vec3( args[8].asDouble, args[9].asDouble, args[10].asDouble ); // ps.ParticlesSpeed = args[11].asDouble; // ps.Size = glm::vec2( args[12].asDouble, args[13].asDouble ); // ps.ParticlesTimeToLive = args[14].asDouble; // ps.TransparencyPolynome = glm::vec2( args[15].asDouble, args[16].asDouble ); // return ps; //}; switch ( projectile->Type ) { case PROJECTILE_TYPE_BULLET: projectile->Orientation = RotationAlignment( MODEL_PROJECTILE_UP, glm::normalize( projectile->Destination - projectile->Origin ) ); //projectile->Scale.z = 1; // TODODP: Move hardcoded length projectile->Orientation = RotationAlignment(MODEL_BEAM_UP, glm::normalize(projectile->Destination - projectile->Origin)); { if (projectile->Tracer) { gfx::ParticleSystem effect = g_SSParticle.GetDefaultParticleSystem(PARTICLE_TYPE_BULLET); effect.ParticlesSpeed = projectile->Speed; effect.TimeToLive = glm::length(distance) / projectile->Speed; effect.ParticlesTimeToLive = glm::length(distance) / projectile->Speed; effect.EmitterPosition = projectile->Origin + glm::vec3(0.0f, 0.5f, 0.0f); effect.Direction = glm::normalize(projectile->Destination - projectile->Origin) * projectile->Scale.z; effect.EmitterPosition = effect.EmitterPosition; if (projectile->Weapon == WEAPON_TANK_CANNON) effect.Size = glm::vec2(0.25f, 0.25f); else if (projectile->Weapon == WEAPON_MACHINE_GUN) effect.Size = glm::vec2(0.15f, 0.15f); g_SSParticle.SpawnParticleSystem(PARTICLE_TYPE_BULLET, effect); projectile->Light.Position = projectile->Position; projectile->Light.Range = 4; projectile->Light.Intensity = 15; projectile->Light.Color = vec4(1.0f, 0.2f, 0.2f, 1.0f); } else { projectile->Light.Position = projectile->Position; projectile->Light.Range = 7; projectile->Light.Intensity = 2; projectile->Light.Color = vec4(0.2f); } } break; case PROJECTILE_TYPE_GRENADE: projectile->Velocity.y = -((projectile->Position.y - projectile->Destination.y) / projectile->TimeLeft - GRAVITY_CONSTANT * projectile->TimeLeft / 2.0f); { gfx::ParticleSystem effect = g_SSParticle.GetDefaultParticleSystem( PARTICLE_TYPE_SMOKE_TRAIL ); effect.EmitterPosition = glm::vec3( FLT_MIN ); projectile->Effect = g_SSParticle.SpawnParticleSystem( PARTICLE_TYPE_SMOKE_TRAIL, effect ); } { projectile->Light.Position = projectile->Position; projectile->Light.Color = glm::vec4( 1.0f ); projectile->Light.Intensity = 5.0f; projectile->Light.Range = 100.0f; } break; case PROJECTILE_TYPE_BEAM: projectile->TimeLeft = 0.1f; projectile->Scale.z = projectile->Weapon == WEAPON_PIERCING_LASER ? 25.0f : glm::length( distance ); // TODODP: Move hardcoded length projectile->Orientation = RotationAlignment( MODEL_BEAM_UP, glm::normalize( projectile->Destination - projectile->Origin ) ); projectile->Destination = projectile->Destination + glm::vec3( 0.0f, 0.5f, 0.0f ); { gfx::ParticleSystem effect = g_SSParticle.GetDefaultParticleSystem( PARTICLE_TYPE_LASER ); effect.EmitterPosition = projectile->Origin;// +glm::vec3(0.0f, 0.5f, 0.0f); effect.Direction = glm::normalize( projectile->Destination - projectile->Origin ) * projectile->Scale.z; if (projectile->Weapon == WEAPON_CUTTER) { effect.Colour = vec4(0.1f, 0.1f, 0.9f, 1); effect.Size = glm::vec2(0.1f, 0.1f); } g_SSParticle .SpawnParticleSystem( PARTICLE_TYPE_LASER, effect ); effect.EmitterPosition = effect.EmitterPosition + glm::normalize( projectile->Destination - projectile->Origin ) * effect.Size.x / 2.0f; g_SSParticle .SpawnParticleSystem( PARTICLE_TYPE_LASER, effect ); if(projectile->Weapon == WEAPON_PIERCING_LASER) { projectile->Light = gfx::Light(); projectile->Light.Position = projectile->Origin; projectile->Light.Direction = projectile->Destination - projectile->Origin; projectile->Light.Length = 25.0f; //glm::length( m_LineLight->Direction ); projectile->Light.Range = 5; projectile->Light.Intensity = 3; projectile->Light.Color = vec4(0.9f,0.1f,0.1f,1); } // if (projectile->Weapon == WEAPON_CUTTER) // { // projectile->Light.Direction = projectile->Destination - projectile->Origin; // projectile->Light.Position = projectile->Destination; // projectile->Light.Color = vec4(0.9f, 0.1f, 0.1f, 1); // projectile->Light.Intensity = 500.0f; // projectile->Light.Range = 100.0f; // projectile->Light.Length = 25.0f; // } } break; case PROJECTILE_TYPE_CONE: projectile->TimeLeft = 0.2f; projectile->Scale.z = g_SSUpgrades.GetUpgrade( WEAPON_PLASMA_SPEWER ).Data.Weapon.AreaOfEffect; projectile->Destination = projectile->Destination + glm::vec3( 0.0f, 0.5f, 0.0f ); { gfx::ParticleSystem effect = g_SSParticle.GetDefaultParticleSystem( PARTICLE_TYPE_CONE ); effect.EmitterPosition = projectile->Origin + glm::vec3( 0.0f, 0.5f, 0.0f ); effect.Direction = glm::normalize( projectile->Destination - projectile->Origin ) * projectile->Scale.z; effect.ParticlesSpeed = projectile->AoE; g_SSParticle.SpawnParticleSystem( PARTICLE_TYPE_CONE, effect ); } break; case PROJECTILE_TYPE_NONE: default: projectile->TimeLeft = 0.0f; break; } }
void GAMECLIENT::on_snapshot() { new_tick = true; // clear out the invalid pointers mem_zero(&gameclient.snap, sizeof(gameclient.snap)); snap.local_cid = -1; // secure snapshot { int num = snap_num_items(SNAP_CURRENT); for(int index = 0; index < num; index++) { SNAP_ITEM item; void *data = snap_get_item(SNAP_CURRENT, index, &item); if(netobj_validate(item.type, data, item.datasize) != 0) { if(config.debug) dbg_msg("game", "invalidated index=%d type=%d (%s) size=%d id=%d", index, item.type, netobj_get_name(item.type), item.datasize, item.id); snap_invalidate_item(SNAP_CURRENT, index); } } } process_events(); if(config.dbg_stress) { if((client_tick()%100) == 0) { char message[64]; int msglen = rand()%(sizeof(message)-1); for(int i = 0; i < msglen; i++) message[i] = 'a'+(rand()%('z'-'a')); message[msglen] = 0; NETMSG_CL_SAY msg; msg.team = rand()&1; msg.message = message; msg.pack(MSGFLAG_VITAL); client_send_msg(); } } // go trough all the items in the snapshot and gather the info we want { snap.team_size[0] = snap.team_size[1] = 0; // TeeComp. for(int i=0; i<MAX_CLIENTS; i++) stats[i].active = false; int num = snap_num_items(SNAP_CURRENT); for(int i = 0; i < num; i++) { SNAP_ITEM item; const void *data = snap_get_item(SNAP_CURRENT, i, &item); if(item.type == NETOBJTYPE_CLIENT_INFO) { const NETOBJ_CLIENT_INFO *info = (const NETOBJ_CLIENT_INFO *)data; int cid = item.id; ints_to_str(&info->name0, 6, clients[cid].name); ints_to_str(&info->skin0, 6, clients[cid].skin_name); clients[cid].use_custom_color = info->use_custom_color; clients[cid].color_body = info->color_body; clients[cid].color_feet = info->color_feet; // prepare the info if(clients[cid].skin_name[0] == 'x' || clients[cid].skin_name[1] == '_') str_copy(clients[cid].skin_name, "default", 64); clients[cid].skin_info.color_body = skins->get_color(clients[cid].color_body); clients[cid].skin_info.color_feet = skins->get_color(clients[cid].color_feet); clients[cid].skin_info.size = 64; // find new skin clients[cid].skin_id = gameclient.skins->find(clients[cid].skin_name); if(clients[cid].skin_id < 0) { clients[cid].skin_id = gameclient.skins->find("default"); if(clients[cid].skin_id < 0) clients[cid].skin_id = 0; } if(clients[cid].use_custom_color) clients[cid].skin_info.texture = gameclient.skins->get(clients[cid].skin_id)->color_texture; else { clients[cid].skin_info.texture = gameclient.skins->get(clients[cid].skin_id)->org_texture; clients[cid].skin_info.color_body = vec4(1,1,1,1); clients[cid].skin_info.color_feet = vec4(1,1,1,1); } clients[cid].update_render_info(cid); gameclient.snap.num_players++; } else if(item.type == NETOBJTYPE_PLAYER_INFO) { const NETOBJ_PLAYER_INFO *info = (const NETOBJ_PLAYER_INFO *)data; clients[info->cid].team = info->team; snap.player_infos[info->cid] = info; if(info->local) { snap.local_cid = item.id; snap.local_info = info; if (info->team == -1) snap.spectate = true; } // calculate team-balance if(info->team != -1) { snap.team_size[info->team]++; stats[info->cid].active = true; } } else if(item.type == NETOBJTYPE_CHARACTER) { const void *old = snap_find_item(SNAP_PREV, NETOBJTYPE_CHARACTER, item.id); if(old) { snap.characters[item.id].active = true; snap.characters[item.id].prev = *((const NETOBJ_CHARACTER *)old); snap.characters[item.id].cur = *((const NETOBJ_CHARACTER *)data); if(snap.characters[item.id].prev.tick) evolve(&snap.characters[item.id].prev, client_prevtick()); if(snap.characters[item.id].cur.tick) evolve(&snap.characters[item.id].cur, client_tick()); } } else if(item.type == NETOBJTYPE_GAME) { snap.gameobj = (NETOBJ_GAME *)data; if(snap.gameobj->game_over != last_game_over) { if(!last_game_over) on_game_over(); else on_game_restart(); last_game_over = snap.gameobj->game_over; } if((snap.gameobj->warmup > 0) != last_warmup) { if(last_warmup) on_warmup_end(); last_warmup = snap.gameobj->warmup > 0; } } else if(item.type == NETOBJTYPE_FLAG) { int fid = item.id%2; snap.flags[fid] = (const NETOBJ_FLAG *)data; if(snap.flags[fid]->carried_by != last_flag_carrier[fid]) { if(snap.flags[fid]->carried_by >= 0) on_flag_grab(fid); last_flag_carrier[fid] = snap.flags[fid]->carried_by; } } } // TeeComp for(int i=0; i<MAX_CLIENTS; i++) { if(stats[i].active && !stats[i].was_active) { stats[i].reset(); // Client connected, reset stats. stats[i].active = true; stats[i].join_date = client_tick(); } stats[i].was_active = stats[i].active; } } // setup local pointers if(snap.local_cid >= 0) { SNAPSTATE::CHARACTERINFO *c = &snap.characters[snap.local_cid]; if(c->active) { snap.local_character = &c->cur; snap.local_prev_character = &c->prev; local_character_pos = vec2(snap.local_character->x, snap.local_character->y); } } else snap.spectate = true; TUNING_PARAMS standard_tuning; SERVER_INFO current_server_info; client_serverinfo(¤t_server_info); if(current_server_info.gametype[0] != '0') { if(strcmp(current_server_info.gametype, "DM") != 0 && strcmp(current_server_info.gametype, "TDM") != 0 && strcmp(current_server_info.gametype, "CTF") != 0) servermode = SERVERMODE_MOD; else if(memcmp(&standard_tuning, &tuning, sizeof(TUNING_PARAMS)) == 0) servermode = SERVERMODE_PURE; else servermode = SERVERMODE_PUREMOD; } // update render info for(int i = 0; i < MAX_CLIENTS; i++) clients[i].update_render_info(i); }
BoundingSphere(vec3 center, vec3 radius) { this->center = vec4(center, 1.0f); this->radius = vec_length(radius); }
AxisAlignedCutPlane::AxisAlignedCutPlane() : Processor() , volume_("volume") , imageInport_("imageInport_") , outport_("outport") , xSlide_("x", "X Slide") , ySlide_("y", "Y Slide") , zSlide_("z", "Z Slide") , disableTF_("disableTF", "Disable transfer function", false, InvalidationLevel::InvalidResources) , tf_("transferfunction", "Transfer function", TransferFunction(), &volume_) , sliceShader_("geometryrendering.vert", "axisalignedcutplaneslice.frag", false) , boundingBoxShader_("geometryrendering.vert", "axisalignedcutplaneboundingbox.frag") , showBoundingBox_("boundingBox", "Show Bounding Box", true) , boundingBoxColor_("boundingBoxColor", "Bounding Box Color", vec4(0.0f, 0.0f, 0.0f, 1.0f)) , renderPointSize_("renderPointSize", "Point Size", 1.0f, 0.001f, 15.0f, 0.001f) , renderLineWidth_("renderLineWidth", "Line Width", 1.0f, 0.001f, 15.0f, 0.001f) , nearestInterpolation_("nearestInterpolation", "Use nearest neighbor interpolation", false) , camera_("camera", "Camera") , trackball_(&camera_) { addPort(volume_); addPort(imageInport_); addPort(outport_); addProperty(xSlide_); addProperty(ySlide_); addProperty(zSlide_); addProperty(disableTF_); addProperty(tf_); addProperty(showBoundingBox_); addProperty(boundingBoxColor_); addProperty(renderPointSize_); addProperty(renderLineWidth_); addProperty(camera_); addProperty(trackball_); imageInport_.setOptional(true); tf_.get().clearPoints(); tf_.get().addPoint(vec2(0.0f, 1.0f), vec4(0.0f, 0.0f, 0.0f, 1.0f)); tf_.get().addPoint(vec2(1.0f, 1.0f), vec4(1.0f, 1.0f, 1.0f, 1.0f)); tf_.setCurrentStateAsDefault(); xSlide_.onChange([&]() { if (volume_.hasData()) xSlide_.createDrawer(volume_.getData()); }); ySlide_.onChange([&]() { if (volume_.hasData()) ySlide_.createDrawer(volume_.getData()); }); zSlide_.onChange([&]() { if (volume_.hasData()) zSlide_.createDrawer(volume_.getData()); }); volume_.onChange([&]() { if (!volume_.hasData()) return; auto vol = volume_.getData(); xSlide_.onVolumeChange(vol); ySlide_.onVolumeChange(vol); zSlide_.onVolumeChange(vol); if (!boundingBoxMesh_) { createBoundingBox(); } boundingBoxMesh_->setModelMatrix(vol->getModelMatrix()); boundingBoxMesh_->setWorldMatrix(vol->getWorldMatrix()); }); boundingBoxColor_.setSemantics(PropertySemantics::Color); setAllPropertiesCurrentStateAsDefault(); createBoundingBox(); }
MeshRenderProcessorGL::MeshRenderProcessorGL() : Processor() , inport_("geometry.inport") , imageInport_("imageInport") , outport_("image.outport") , camera_("camera", "Camera") , centerViewOnGeometry_("centerView", "Center view on geometry") , setNearFarPlane_("setNearFarPlane", "Calculate Near and Far Plane") , resetViewParams_("resetView", "Reset Camera") , trackball_(&camera_) , overrideColorBuffer_("overrideColorBuffer", "Override Color Buffer", false , INVALID_RESOURCES) , overrideColor_("overrideColor", "Override Color", vec4(0.75f, 0.75f, 0.75f, 1.0f), vec4(0.0f), vec4(1.0f)) , geomProperties_("geometry", "Geometry Rendering Properties") , cullFace_("cullFace", "Cull Face") , polygonMode_("polygonMode", "Polygon Mode") , renderPointSize_("renderPointSize", "Point Size", 1.0f, 0.001f, 15.0f, 0.001f) , renderLineWidth_("renderLineWidth", "Line Width", 1.0f, 0.001f, 15.0f, 0.001f) , lightingProperty_("lighting", "Lighting", &camera_) , layers_("layers", "Layers") , colorLayer_("colorLayer", "Color", true, INVALID_RESOURCES) , texCoordLayer_("texCoordLayer", "Texture Coordinates", false, INVALID_RESOURCES) , normalsLayer_("normalsLayer", "Normals (World Space)", false, INVALID_RESOURCES) , viewNormalsLayer_("viewNormalsLayer", "Normals (View space)", false, INVALID_RESOURCES) , shader_("geometryrendering.vert", "geometryrendering.frag", false) { addPort(inport_); addPort(imageInport_); addPort(outport_); addProperty(camera_); centerViewOnGeometry_.onChange(this, &MeshRenderProcessorGL::centerViewOnGeometry); addProperty(centerViewOnGeometry_); setNearFarPlane_.onChange(this, &MeshRenderProcessorGL::setNearFarPlane); addProperty(setNearFarPlane_); resetViewParams_.onChange([this]() { camera_.resetCamera(); }); addProperty(resetViewParams_); outport_.addResizeEventListener(&camera_); inport_.onChange(this, &MeshRenderProcessorGL::updateDrawers); cullFace_.addOption("culldisable", "Disable", GL_NONE); cullFace_.addOption("cullfront", "Front", GL_FRONT); cullFace_.addOption("cullback", "Back", GL_BACK); cullFace_.addOption("cullfrontback", "Front & Back", GL_FRONT_AND_BACK); cullFace_.set(GL_NONE); polygonMode_.addOption("polypoint", "Points", GL_POINT); polygonMode_.addOption("polyline", "Lines", GL_LINE); polygonMode_.addOption("polyfill", "Fill", GL_FILL); polygonMode_.set(GL_FILL); polygonMode_.onChange(this, &MeshRenderProcessorGL::changeRenderMode); geomProperties_.addProperty(cullFace_); geomProperties_.addProperty(polygonMode_); geomProperties_.addProperty(renderPointSize_); geomProperties_.addProperty(renderLineWidth_); geomProperties_.addProperty(overrideColorBuffer_); geomProperties_.addProperty(overrideColor_); overrideColor_.setSemantics(PropertySemantics::Color); overrideColor_.setVisible(false); overrideColorBuffer_.onChange([&](){overrideColor_.setVisible(overrideColorBuffer_.get()); }); float lineWidthRange[2]; float increment; glGetFloatv(GL_LINE_WIDTH_RANGE, lineWidthRange); glGetFloatv(GL_LINE_WIDTH_GRANULARITY, &increment); renderLineWidth_.setMinValue(lineWidthRange[0]); renderLineWidth_.setMaxValue(lineWidthRange[1]); renderLineWidth_.setIncrement(increment); renderLineWidth_.setVisible(false); renderPointSize_.setVisible(false); addProperty(geomProperties_); addProperty(lightingProperty_); addProperty(trackball_); addProperty(layers_); layers_.addProperty(colorLayer_); layers_.addProperty(texCoordLayer_); layers_.addProperty(normalsLayer_); layers_.addProperty(viewNormalsLayer_); setAllPropertiesCurrentStateAsDefault(); }
void main() { vUv = vec2(uv.x, 1.0 - uv.y); gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }
void main() { vec4 color = texture2D(backgroundSampler, v_texCoord); gl_FragColor = vec4(backgroundColor.rgb, color.a); }
bool LayerFilterRenderer::initializeSharedGLObjects() { // See also TextureMapperShaderManager.cpp char standardVertexShaderString[] = "attribute vec4 a_position; \n" "attribute vec2 a_texCoord; \n" "varying vec2 v_texCoord; \n" "void main() \n" "{ \n" " gl_Position = a_position; \n" " v_texCoord = a_texCoord; \n" "} \n"; char offsetVertexShaderString[] = "attribute vec4 a_position; \n" "attribute vec2 a_texCoord; \n" "uniform mediump vec2 u_offset; \n" "varying vec2 v_texCoord; \n" "void main() \n" "{ \n" " gl_Position = a_position; \n" " v_texCoord = a_texCoord - u_offset; \n" "} \n"; #define STANDARD_FILTER(x...) \ "precision mediump float; \n"\ "\n"\ "varying mediump vec2 v_texCoord;\n"\ "uniform lowp sampler2D s_texture;\n"\ "uniform highp float u_amount;\n"\ #x\ "void main(void)\n { gl_FragColor = shade(texture2D(s_texture, v_texCoord)); }" #define BLUR_FILTER(x...) \ "precision highp float; \n"\ "\n"\ "varying mediump vec2 v_texCoord;\n"\ "uniform lowp sampler2D s_texture;\n"\ "uniform highp float u_amount;\n"\ "uniform highp float u_blurSize;\n"\ "const float pi = 3.1415927;\n"\ #x\ "void main(void)\n"\ "{\n"\ "vec3 incr;\n"\ "incr.x = 1.0 / (sqrt(2.0 * pi) * u_amount);\n"\ "incr.y = exp(-0.5 / (u_amount * u_amount));\n"\ "incr.z = incr.y * incr.y;\n"\ "\n"\ "vec4 avg = vec4(0.0, 0.0, 0.0, 0.0);\n"\ "float coefficientSum = 0.0;\n"\ "\n"\ "avg += texture2D(s_texture, v_texCoord.xy) * incr.x;\n"\ "coefficientSum += incr.x;\n"\ "incr.xy *= incr.yz;\n"\ "\n"\ "for (float i = 1.0; i <= u_amount; i++) {\n"\ " avg += texture2D(s_texture, v_texCoord.xy - i * u_blurSize * blurMultiplyVec) * incr.x;\n"\ " avg += texture2D(s_texture, v_texCoord.xy + i * u_blurSize * blurMultiplyVec) * incr.x;\n"\ " coefficientSum += 2.0 * incr.x;\n"\ " incr.xy *= incr.yz;\n"\ "}\n"\ "\n"\ "gl_FragColor = avg / coefficientSum;\n"\ "}" const char* shaderStrs[LayerData::NumberOfCSSFilterShaders]; shaderStrs[LayerData::CSSFilterShaderGrayscale] = STANDARD_FILTER( lowp vec4 shade(lowp vec4 color) { lowp float amount = 1.0 - u_amount; return vec4((0.2126 + 0.7874 * amount) * color.r + (0.7152 - 0.7152 * amount) * color.g + (0.0722 - 0.0722 * amount) * color.b, (0.2126 - 0.2126 * amount) * color.r + (0.7152 + 0.2848 * amount) * color.g + (0.0722 - 0.0722 * amount) * color.b, (0.2126 - 0.2126 * amount) * color.r + (0.7152 - 0.7152 * amount) * color.g + (0.0722 + 0.9278 * amount) * color.b, color.a); }
void main(void)\ {\ gl_Position = vec4(point.x / scene.x - 1.0, 1.0 - point.y / scene.y, 0.0, 1.0);\ v_tex_coord = tex_coord;\ v_color = color;\ }";
void Init_Menu_Win() { ItemDef *item; Menu_Win = new MenuDef( "win" ); Engine->UI->PushMenu( Menu_Win ); Menu_Win->OnOpen = OnOpen; item = new ItemDef( ITYPE_DEFAULT, ITEMFLAG_IMAGE, "background" ); Menu_Win->PushItem( item ); { item->rect = vec4( 0,0,640,480 ); item->mat = NULL; item->color = vec4( 0,0,0,0.4 ); } item = new ItemDef( ITYPE_DEFAULT, ITEMFLAG_TEXT, "as" ); Menu_Win->PushItem( item ); { item->rect = vec4( 320,170,0,0 ); item->textColor = vec4( 0.0,0.8,0,1.0 ); item->textAlign = vec2(1,0); item->fontSize = 2.6f; item->font = 0; item->string = "YOU WIN"; } item = new ItemDef( ITYPE_DEFAULT, ITEMFLAG_TEXT, "as" ); Menu_Win->PushItem( item ); { item->rect = vec4( 320,190,0,0 ); item->textColor = vec4( 0.96,0.96,0.96,1 ); item->textAlign = vec2(1,0); item->fontSize = 1.3f; item->font = 0; //item->string = info;//"WANT TO FART AGAIN?"; score = item; } item = new ItemDef( ITYPE_BUTTON, (ITEMFLAG_IMAGE|ITEMFLAG_TEXT), "button-yes" ); Menu_Win->PushItem( item ); { item->rect = vec4( 225,230,90,40 ); item->mat = NULL; item->color = vec4(0.1,0.1,0.1,0.4); item->textColor = vec4( 0.92,0.92,0.92,1.0 ); item->textOffset = vec2( 45,25 ); item->fontSize = 1.3f; item->textAlign = vec2(1,0); item->font = 0; item->string = "NEXT LEVEL"; item->OnFocus = ButtonFocus; item->OnAction = ButtonYesAction; item->visible = true; } item = new ItemDef( ITYPE_BUTTON, (ITEMFLAG_IMAGE|ITEMFLAG_TEXT), "button-no" ); Menu_Win->PushItem( item ); { item->rect = vec4( 325,230,90,40 ); item->mat = NULL; item->color = vec4(0.1,0.1,0.1,0.4); item->textColor = vec4( 0.92,0.92,0.92,1.0 ); item->textOffset = vec2( 45,25 ); item->fontSize = 1.3f; item->textAlign = vec2(1,0); item->font = 0; item->string = "BACK TO MENU"; item->OnFocus = ButtonFocus; item->OnAction = ButtonNoAction; item->visible = true; } }
void main(void) { gl_Position = charMat * vec4(pos.xy, 0.0, 1.0); charDataOut = charDataIn; texCoords = pos.zw; }
void Trans_Mesh::Draw(const Base_Camera* camera, float dt){ Graphics::SetTopology(PRIM_TRIANGLELIST); Graphics::DepthStates::NoDepthTest.Bind(); Graphics::RasterizerStates::CullNone.Bind(); Graphics::BlendStates::No_Blend.Bind(); VB[0].BindAsVertexBuffer(); IB.BindAsIndexBuffer(); // first axis Batch* cone_batch = Batches[0]; Batch* rod_batch = Batches[1]; struct tempstruct{ mat4 vp; vec4 color; }; tempstruct t; mat4 bvtrans, bvaxis, rodscale, rodtrans; const float offaxis =10.0f; rodscale.setupScale(offaxis/3.0f, .1f, .1f); const float distaway = 120.0f; LastCamPosition = camera->Position; vec3 transpost = GetPosition()-LastCamPosition; transpost.normalize(); //FIRST AXIS.. RED AND X bvtrans.setupTranslation((transpost*distaway) + LastCamPosition+vec3(offaxis, 0.0f, 0.0f)); bvaxis.setupTranslation(vec3(-1.0f, 0, 0)); t.vp = bvaxis*bvtrans*camera->VP;// we have to move the BV that was pregenerated into the correct position and scale it t.vp.Transpose(); t.color = vec4(XAxis_Color, 1);//red ==x CBuffer0.Update(&t); cone_batch->GetVS()->Bind(); cone_batch->GetVS()->SetConstantBuffer(CBuffer0, 0); cone_batch->GetPS()->Bind(); Graphics::DrawIndexed(cone_batch->StartIndex, cone_batch->NumIndices); //now draw the rod bvtrans.setupTranslation((transpost*distaway) + LastCamPosition); rodtrans.setupTranslation(vec3(1.3f, 0, 0)); t.vp = rodtrans*rodscale*bvtrans*camera->VP;// we have to move the BV that was pregenerated into the correct position and scale it t.vp.Transpose(); CBuffer0.Update(&t); cone_batch->GetVS()->SetConstantBuffer(CBuffer0, 0); Graphics::DrawIndexed(rod_batch->StartIndex, rod_batch->NumIndices); //SECOND AXIS. .. BLUE AND Z mat4 rot; rot.setupRotateY(-Pi/2.0f); bvaxis.setupTranslation( 0.0f, 0.0f, -1.0f); bvtrans.setupTranslation((transpost*distaway) + LastCamPosition+ vec3(0.0f, 0.0f, offaxis)); t.vp = bvaxis*rot*bvtrans*camera->VP; t.vp.Transpose(); t.color = vec4(ZAxis_Color, 1); CBuffer0.Update(&t); cone_batch->GetVS()->SetConstantBuffer(CBuffer0, 0); Graphics::DrawIndexed(cone_batch->StartIndex, cone_batch->NumIndices); //now draw the rod bvtrans.setupTranslation((transpost*distaway) + LastCamPosition+ vec3(1.0f, 0, offaxis/2.0f)); t.vp = rodscale*rot*bvtrans*camera->VP;// we have to move the BV that was pregenerated into the correct position and scale it t.vp.Transpose(); CBuffer0.Update(&t); cone_batch->GetVS()->SetConstantBuffer(CBuffer0, 0); Graphics::DrawIndexed(rod_batch->StartIndex, rod_batch->NumIndices); //THIRD AXIS . . . . GREEN AND Y rot.setupRotateZ(Pi/2.0f); bvtrans.setupTranslation((transpost*distaway) + LastCamPosition + vec3(0.0f, offaxis, 0.0f)); bvaxis.setupTranslation(0.0f, -1.0f, 0.0f); t.vp = bvaxis*rot*bvtrans*camera->VP; t.vp.Transpose(); t.color = vec4(YAxis_Color, 1); CBuffer0.Update(&t); cone_batch->GetVS()->SetConstantBuffer(CBuffer0, 0); Graphics::DrawIndexed(cone_batch->StartIndex, cone_batch->NumIndices); //now draw the rod bvtrans.setupTranslation((transpost*distaway) + LastCamPosition+ vec3(1.0f, offaxis/2.0f, 0.0f)); rodtrans.setupTranslation(vec3(0, 1.3f, 0)); t.vp = rodtrans*rodscale*rot*bvtrans*camera->VP;// we have to move the BV that was pregenerated into the correct position and scale it t.vp.Transpose(); CBuffer0.Update(&t); cone_batch->GetVS()->SetConstantBuffer(CBuffer0, 0); Graphics::DrawIndexed(rod_batch->StartIndex, rod_batch->NumIndices); }
/* Use mesa's clipping algorithms, translated to GEN4 assembly. */ void brw_clip_tri( struct brw_clip_compile *c ) { struct brw_compile *p = &c->func; struct brw_indirect vtx = brw_indirect(0, 0); struct brw_indirect vtxPrev = brw_indirect(1, 0); struct brw_indirect vtxOut = brw_indirect(2, 0); struct brw_indirect plane_ptr = brw_indirect(3, 0); struct brw_indirect inlist_ptr = brw_indirect(4, 0); struct brw_indirect outlist_ptr = brw_indirect(5, 0); struct brw_indirect freelist_ptr = brw_indirect(6, 0); struct brw_instruction *plane_loop; struct brw_instruction *plane_active; struct brw_instruction *vertex_loop; struct brw_instruction *next_test; struct brw_instruction *prev_test; brw_MOV(p, get_addr_reg(vtxPrev), brw_address(c->reg.vertex[2]) ); brw_MOV(p, get_addr_reg(plane_ptr), brw_clip_plane0_address(c)); brw_MOV(p, get_addr_reg(inlist_ptr), brw_address(c->reg.inlist)); brw_MOV(p, get_addr_reg(outlist_ptr), brw_address(c->reg.outlist)); brw_MOV(p, get_addr_reg(freelist_ptr), brw_address(c->reg.vertex[3]) ); plane_loop = brw_DO(p, BRW_EXECUTE_1); { /* if (planemask & 1) */ brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ); brw_AND(p, vec1(brw_null_reg()), c->reg.planemask, brw_imm_ud(1)); plane_active = brw_IF(p, BRW_EXECUTE_1); { /* vtxOut = freelist_ptr++ */ brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(freelist_ptr) ); brw_ADD(p, get_addr_reg(freelist_ptr), get_addr_reg(freelist_ptr), brw_imm_uw(c->nr_regs * REG_SIZE)); if (c->key.nr_userclip) brw_MOV(p, c->reg.plane_equation, deref_4f(plane_ptr, 0)); else brw_MOV(p, c->reg.plane_equation, deref_4b(plane_ptr, 0)); brw_MOV(p, c->reg.loopcount, c->reg.nr_verts); brw_MOV(p, c->reg.nr_verts, brw_imm_ud(0)); vertex_loop = brw_DO(p, BRW_EXECUTE_1); { /* vtx = *input_ptr; */ brw_MOV(p, get_addr_reg(vtx), deref_1uw(inlist_ptr, 0)); /* IS_NEGATIVE(prev) */ brw_set_conditionalmod(p, BRW_CONDITIONAL_L); brw_DP4(p, vec4(c->reg.dpPrev), deref_4f(vtxPrev, c->offset[VERT_RESULT_HPOS]), c->reg.plane_equation); prev_test = brw_IF(p, BRW_EXECUTE_1); { /* IS_POSITIVE(next) */ brw_set_conditionalmod(p, BRW_CONDITIONAL_GE); brw_DP4(p, vec4(c->reg.dp), deref_4f(vtx, c->offset[VERT_RESULT_HPOS]), c->reg.plane_equation); next_test = brw_IF(p, BRW_EXECUTE_1); { /* Coming back in. */ brw_ADD(p, c->reg.t, c->reg.dpPrev, negate(c->reg.dp)); brw_math_invert(p, c->reg.t, c->reg.t); brw_MUL(p, c->reg.t, c->reg.t, c->reg.dpPrev); /* If (vtxOut == 0) vtxOut = vtxPrev */ brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, get_addr_reg(vtxOut), brw_imm_uw(0) ); brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(vtxPrev) ); brw_set_predicate_control(p, BRW_PREDICATE_NONE); brw_clip_interp_vertex(c, vtxOut, vtxPrev, vtx, c->reg.t, GL_FALSE); /* *outlist_ptr++ = vtxOut; * nr_verts++; * vtxOut = 0; */ brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxOut)); brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short))); brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1)); brw_MOV(p, get_addr_reg(vtxOut), brw_imm_uw(0) ); } brw_ENDIF(p, next_test); } prev_test = brw_ELSE(p, prev_test); { /* *outlist_ptr++ = vtxPrev; * nr_verts++; */ brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxPrev)); brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short))); brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1)); /* IS_NEGATIVE(next) */ brw_set_conditionalmod(p, BRW_CONDITIONAL_L); brw_DP4(p, vec4(c->reg.dp), deref_4f(vtx, c->offset[VERT_RESULT_HPOS]), c->reg.plane_equation); next_test = brw_IF(p, BRW_EXECUTE_1); { /* Going out of bounds. Avoid division by zero as we * know dp != dpPrev from DIFFERENT_SIGNS, above. */ brw_ADD(p, c->reg.t, c->reg.dp, negate(c->reg.dpPrev)); brw_math_invert(p, c->reg.t, c->reg.t); brw_MUL(p, c->reg.t, c->reg.t, c->reg.dp); /* If (vtxOut == 0) vtxOut = vtx */ brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, get_addr_reg(vtxOut), brw_imm_uw(0) ); brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(vtx) ); brw_set_predicate_control(p, BRW_PREDICATE_NONE); brw_clip_interp_vertex(c, vtxOut, vtx, vtxPrev, c->reg.t, GL_TRUE); /* *outlist_ptr++ = vtxOut; * nr_verts++; * vtxOut = 0; */ brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxOut)); brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short))); brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1)); brw_MOV(p, get_addr_reg(vtxOut), brw_imm_uw(0) ); } brw_ENDIF(p, next_test); } brw_ENDIF(p, prev_test); /* vtxPrev = vtx; * inlist_ptr++; */ brw_MOV(p, get_addr_reg(vtxPrev), get_addr_reg(vtx)); brw_ADD(p, get_addr_reg(inlist_ptr), get_addr_reg(inlist_ptr), brw_imm_uw(sizeof(short))); /* while (--loopcount != 0) */ brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ); brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1)); } brw_WHILE(p, vertex_loop); /* vtxPrev = *(outlist_ptr-1) OR: outlist[nr_verts-1] * inlist = outlist * inlist_ptr = &inlist[0] * outlist_ptr = &outlist[0] */ brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_w(-2)); brw_MOV(p, get_addr_reg(vtxPrev), deref_1uw(outlist_ptr, 0)); brw_MOV(p, brw_vec8_grf(c->reg.inlist.nr, 0), brw_vec8_grf(c->reg.outlist.nr, 0)); brw_MOV(p, get_addr_reg(inlist_ptr), brw_address(c->reg.inlist)); brw_MOV(p, get_addr_reg(outlist_ptr), brw_address(c->reg.outlist)); } brw_ENDIF(p, plane_active); /* plane_ptr++; */ brw_ADD(p, get_addr_reg(plane_ptr), get_addr_reg(plane_ptr), brw_clip_plane_stride(c)); /* nr_verts >= 3 */ brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_GE, c->reg.nr_verts, brw_imm_ud(3)); /* && (planemask>>=1) != 0 */ brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ); brw_SHR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud(1)); } brw_WHILE(p, plane_loop); }
void main() { float newZoom = min(cameraZoom,1.0); // vec4 tex4 = texture2D(Texture4, TexCoord0.xy); // vec4 tex5 = texture2D(Texture5, TexCoord0.xy); // vec4 tex6 = texture2D(Texture6, TexCoord0.xy); vec4 tex7 = texture2D(Texture7, TexCoord0.xy); vec3 worldPosition = tex7.xyz; // vec2 tcMod = (vec2(TexCoord0.x,1.0-TexCoord0.y)*2.0-1.0 ); // tcMod.x *= bufferDim.x/(newZoom); // tcMod.y *= bufferDim.y/(newZoom); // tcMod.y -= cameraPos.z; // vec3 worldPosition = vec3(0.0,0.0,0.0); // worldPosition.x = tcMod.y + tcMod.x/2.0; // worldPosition.y = tcMod.y - tcMod.x/2.0; // worldPosition.x += cameraPos.x; // worldPosition.y += cameraPos.y; // worldPosition.z = 0.0; // float tilt = tiltAmount; // float itilt = 1.0-tiltAmount; // float baseHeight = 0.0; // vec3 worldPosition = vec3(0.0,0.0,0.0); // vec2 ssCoord = vec2(0.0); // ssCoord = vec2(TexCoord0.x,1.0-TexCoord0.y)*2.0-1.0; // ssCoord.x *= bufferDim.x/(newZoom); // ssCoord.y *= bufferDim.y/(newZoom); // ssCoord.y -= cameraPos.z*tilt*2.0; // ssCoord.y += baseHeight*tilt*2.0; // worldPosition.x = (ssCoord.y*0.5/itilt + ssCoord.x*0.5); // worldPosition.y = (ssCoord.y*0.5/itilt - ssCoord.x*0.5); // worldPosition.z = baseHeight; // worldPosition.x += cameraPos.x; // worldPosition.y += cameraPos.y; vec2 newPos = worldPosition.xy/waveSpacing; // float wm = mix( // abs( // sin( // (curTime)/500.0 + (TexCoord0.x + TexCoord0.y) * 12.0 // ) // ), // 0.25, // 1.0 // )*2.0; float waveh = (waveHeight(newPos) )*0.5+0.5; vec3 waven = (normalize( waveNormal(newPos) )+1.0)/2.0; gl_FragData[0] = vec4(waven,waveh); }
void PointListRenderer::generateDisplayList(const std::vector<vec3>& pointList) { if (glIsList(displayList_)) glDeleteLists(displayList_, 1); displayList_ = glGenLists(1); glNewList(displayList_, GL_COMPILE); glPushAttrib(GL_ALL_ATTRIB_BITS); if (coordinateSystem_.get() != "world") { glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); if (coordinateSystem_.get() == "viewport") { glTranslatef(-1.f, -1.f, 0.f); glScalef(2.f/viewport_.x, 2.f/viewport_.y, 1.f); } } if (!depthTest_.get()) glDisable(GL_DEPTH_TEST); // enable lighting for illuminated spheres if (renderingPrimitiveProp_.get() == "illuminated-spheres") { glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_AMBIENT, vec4(0.3f, 0.3f, 0.3f, 1.f).elem); glLightfv(GL_LIGHT0, GL_DIFFUSE, vec4(0.6f, 0.6f, 0.6f, 1.f).elem); glLightfv(GL_LIGHT0, GL_SPECULAR, vec4(0.6f, 0.6f, 0.6f, 1.f).elem); glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 128.f); tgt::Material material(color_.get(), color_.get(), color_.get(), 75.f); material.activate(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glLightfv(GL_LIGHT0, GL_POSITION, vec4(1.f, 1.f, 10.f, 1.f).elem); glPopMatrix(); } // render: point primitives if (renderingPrimitiveProp_.get() == "points") { glColor4fv(color_.get().elem); glPointSize(pointSize_.get()); if (pointSmooth_.get()) glEnable(GL_POINT_SMOOTH); glBegin(GL_POINTS); for (size_t i=0; i<pointList.size(); ++i) { tgt::vertex(pointList[i]); } glEnd(); } // render: line strip if (renderingPrimitiveProp_.get() == "line-strip") { glColor4fv(color_.get().elem); glLineWidth(pointSize_.get()); if (pointSmooth_.get()) glEnable(GL_LINE_SMOOTH); glBegin(GL_LINE_STRIP); for (size_t i=0; i<pointList.size(); ++i) { tgt::vertex(pointList[i]); } glEnd(); } // render: spheres else if (renderingPrimitiveProp_.get() == "spheres" || renderingPrimitiveProp_.get() == "illuminated-spheres") { GLUquadricObj* quadric = gluNewQuadric(); glColor4fv(color_.get().elem); for (size_t i=0; i<pointList.size(); ++i) { glPushMatrix(); tgt::translate(pointList[i]); gluSphere(quadric, sphereDiameter_.get(), sphereSlicesStacks_.get(), sphereSlicesStacks_.get()); glPopMatrix(); } gluDeleteQuadric(quadric); } if (coordinateSystem_.get() != "world") { glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); } glPopAttrib(); glEndList(); }
void main() { vec4 baseval = texture2D( u_Texture0, v_TexCoords ); vec3 offsetNorm; offsetNorm.rg = (baseval.rg-0.5)*2.0; offsetNorm.b = abs(sqrt( abs(1.0-(offsetNorm.r*offsetNorm.r+offsetNorm.g*offsetNorm.g) ))); offsetNorm *= 2.0; vec4 samp; vec3 tc; int i; int j; int k; float fl; float fi; float fj; float fk; float dis; float fit; float fjt; float rad; const int iMax = 8; const int jMax = 5; const float fiMax = float(iMax); const float fjMax = float(jMax); const float pi = 3.14159; float totHits = 0.0; float totRays = 0.0; float hitPower; float phi; float theta; int counter = 1; for (int j = 2; j < jMax; j++) { fjt = pow( 2.0, float(j) ); hitPower = (fjMax-fjt)/fjMax; for (int i = 0; i < iMax; i++) { fit = float(i)*pi/fiMax; theta = fit/2.0;//1.5*pi;////2.0*pi - fit/2.0; phi = 2.0*fit; rad = fjt*fit/pi; fi = rad*cos(phi+fjt)*sin(theta); fj = rad*sin(phi+fjt)*sin(theta); fk = rad*cos(theta); tc.x = (fi + offsetNorm.x)/u_Resolution.x; tc.y = ( (fj - offsetNorm.y) + (fk + offsetNorm.z) )/u_Resolution.y; tc.z = clamp(baseval.b + (fk + offsetNorm.z)/255.0,0.0,u_MaxLayers); dis = clamp(sqrt(fi*fi+fj*fj+fk*fk)/fjt,0.0,1.0); samp = texture2D( u_Texture0, v_TexCoords + tc.xy ); if (samp.b < tc.z) { totHits += hitPower; } totRays += hitPower; } counter++; } float resVal = (totHits/totRays); resVal = clamp(resVal,0.0,1.0); resVal = pow(resVal,6.0); gl_FragColor = vec4(baseval.rgb,resVal); //gl_FragColor = vec4(resVal,resVal,resVal,1.0); }
void Widget::drawSoftBorderQuad(Renderer *renderer, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState, const float x0, const float y0, const float x1, const float y1, const float borderWidth, const float colScale, const float transScale){ if (corner == TEXTURE_NONE){ ubyte pixels[32][32][4]; for (int y = 0; y < 32; y++){ for (int x = 0; x < 32; x++){ int r = 255 - int(powf(sqrtf(float(x * x + y * y)) * (255.0f / 31.0f), 1.0f)); if (r < 0) r = 0; pixels[y][x][0] = r; pixels[y][x][1] = r; pixels[y][x][2] = r; pixels[y][x][3] = r; } } Image img; img.loadFromMemory(pixels, FORMAT_RGBA8, 32, 32, 1, 1, false); corner = renderer->addTexture(img, false, linearClamp); } float x0bw = x0 + borderWidth; float y0bw = y0 + borderWidth; float x1bw = x1 - borderWidth; float y1bw = y1 - borderWidth; TexVertex border[] = { TexVertex(vec2(x0, y0bw), vec2(1, 0)), TexVertex(vec2(x0, y0 ), vec2(1, 1)), TexVertex(vec2(x0bw, y0bw), vec2(0, 0)), TexVertex(vec2(x0bw, y0 ), vec2(0, 1)), TexVertex(vec2(x1bw, y0bw), vec2(0, 0)), TexVertex(vec2(x1bw, y0 ), vec2(0, 1)), TexVertex(vec2(x1bw, y0 ), vec2(0, 1)), TexVertex(vec2(x1, y0 ), vec2(1, 1)), TexVertex(vec2(x1bw, y0bw), vec2(0, 0)), TexVertex(vec2(x1, y0bw), vec2(1, 0)), TexVertex(vec2(x1bw, y1bw), vec2(0, 0)), TexVertex(vec2(x1, y1bw), vec2(1, 0)), TexVertex(vec2(x1, y1bw), vec2(1, 0)), TexVertex(vec2(x1, y1 ), vec2(1, 1)), TexVertex(vec2(x1bw, y1bw), vec2(0, 0)), TexVertex(vec2(x1bw, y1 ), vec2(0, 1)), TexVertex(vec2(x0bw, y1bw), vec2(0, 0)), TexVertex(vec2(x0bw, y1 ), vec2(0, 1)), TexVertex(vec2(x0bw, y1 ), vec2(0, 1)), TexVertex(vec2(x0, y1 ), vec2(1, 1)), TexVertex(vec2(x0bw, y1bw), vec2(0, 0)), TexVertex(vec2(x0, y1bw), vec2(1, 0)), TexVertex(vec2(x0bw, y0bw), vec2(0, 0)), TexVertex(vec2(x0, y0bw), vec2(1, 0)), }; vec4 col = color * vec4(colScale, colScale, colScale, transScale); renderer->drawTextured(PRIM_TRIANGLE_STRIP, border, elementsOf(border), corner, linearClamp, blendSrcAlpha, depthState, &col); // Center vec2 center[] = { vec2(x0bw, y0bw), vec2(x1bw, y0bw), vec2(x0bw, y1bw), vec2(x1bw, y1bw) }; renderer->drawPlain(PRIM_TRIANGLE_STRIP, center, 4, blendSrcAlpha, depthState, &col); }
void RDirNode::updateFilesVBO(quadbuf& buffer, float dt) const{ if(in_frustum) { for(std::list<RFile*>::const_iterator it = files.begin(); it!=files.end(); it++) { RFile* f = *it; if(f->isHidden()) continue; vec3 col = f->getColour(); float alpha = f->getAlpha(); buffer.add(f->graphic->textureid, f->getAbsolutePos() - f->dims*0.5f, f->dims, vec4(col.x, col.y, col.z, alpha)); } } for(std::list<RDirNode*>::const_iterator it = children.begin(); it != children.end(); it++) { RDirNode* node = (*it); node->updateFilesVBO(buffer,dt); } }
void CItems::RenderLaser(const struct CNetObj_Laser *pCurrent) { vec2 Pos = vec2(pCurrent->m_X, pCurrent->m_Y); vec2 From = vec2(pCurrent->m_FromX, pCurrent->m_FromY); vec2 Dir = normalize(Pos-From); float Ticks = (Client()->GameTick() - pCurrent->m_StartTick) + Client()->IntraGameTick(); // H-Client (Vanilla #1157) float Ms = (Ticks/50.0f) * 1000.0f; float a = Ms / m_pClient->m_Tuning.m_LaserBounceDelay; a = clamp(a, 0.0f, 1.0f); float Ia = 1-a; vec2 Out, Border; Graphics()->BlendNormal(); Graphics()->TextureSet(-1); Graphics()->QuadsBegin(); //vec4 inner_color(0.15f,0.35f,0.75f,1.0f); //vec4 outer_color(0.65f,0.85f,1.0f,1.0f); vec3 Rgb = HslToRgb(vec3(g_Config.m_hcLaserColorHue/255.0f, g_Config.m_hcLaserColorSat/255.0f, g_Config.m_hcLaserColorLht/255.0f)); //H-Client // do outline vec4 OuterColor(0.075f, 0.075f, 0.25f, 1.0f); if (g_Config.m_hcLaserCustomColor) OuterColor = vec4(Rgb.r+0.25f, Rgb.g+0.25f, Rgb.b-0.75f, g_Config.m_hcLaserColorAlpha/255.0f); Graphics()->SetColor(OuterColor.r, OuterColor.g, OuterColor.b, 1.0f); Out = vec2(Dir.y, -Dir.x) * (7.0f*Ia); IGraphics::CFreeformItem Freeform( From.x-Out.x, From.y-Out.y, From.x+Out.x, From.y+Out.y, Pos.x-Out.x, Pos.y-Out.y, Pos.x+Out.x, Pos.y+Out.y); Graphics()->QuadsDrawFreeform(&Freeform, 1); // do inner vec4 InnerColor(0.5f, 0.5f, 1.0f, 1.0f); if (g_Config.m_hcLaserCustomColor) InnerColor = vec4(Rgb.r, Rgb.g, Rgb.b, g_Config.m_hcLaserColorAlpha/255.0f); Out = vec2(Dir.y, -Dir.x) * (5.0f*Ia); Graphics()->SetColor(InnerColor.r, InnerColor.g, InnerColor.b, 1.0f); // center Freeform = IGraphics::CFreeformItem( From.x-Out.x, From.y-Out.y, From.x+Out.x, From.y+Out.y, Pos.x-Out.x, Pos.y-Out.y, Pos.x+Out.x, Pos.y+Out.y); Graphics()->QuadsDrawFreeform(&Freeform, 1); Graphics()->QuadsEnd(); //H-Client CServerInfo Info; Client()->GetServerInfo(&Info); if(g_Config.m_hcLaserCustomColor && !str_find_nocase(Info.m_aGameType, "race") && length(Pos-From) != 0 && Pos != From) { vec2 cPos = From; for (int i=0; i<length(From-Pos); i++) { m_pClient->m_pEffects->LaserTrail(cPos, Dir, InnerColor); cPos += Dir; } } // // render head { Graphics()->BlendNormal(); Graphics()->TextureSet(g_pData->m_aImages[IMAGE_PARTICLES].m_Id); Graphics()->QuadsBegin(); int Sprites[] = {SPRITE_PART_SPLAT01, SPRITE_PART_SPLAT02, SPRITE_PART_SPLAT03}; RenderTools()->SelectSprite(Sprites[Client()->GameTick()%3]); Graphics()->QuadsSetRotation(Client()->GameTick()); Graphics()->SetColor(OuterColor.r, OuterColor.g, OuterColor.b, 1.0f); IGraphics::CQuadItem QuadItem(Pos.x, Pos.y, 24, 24); Graphics()->QuadsDraw(&QuadItem, 1); Graphics()->SetColor(InnerColor.r, InnerColor.g, InnerColor.b, 1.0f); QuadItem = IGraphics::CQuadItem(Pos.x, Pos.y, 20, 20); Graphics()->QuadsDraw(&QuadItem, 1); Graphics()->QuadsEnd(); } Graphics()->BlendNormal(); }
void main(void){ \n\ gl_FragColor=vec4((texture2D(tex,gl_TexCoord[0].st).xyz),1.0); \n\ } \n\
Our_Model::Our_Model(){ vertex_positions.push_back(vec4(-1, -1, 0, 1)); vertex_positions.push_back(vec4(1, -1, 0, 1)); vertex_positions.push_back(vec4(0, 0, 1, 1)); vertex_positions.push_back(vec4(1, -1, 0, 1)); vertex_positions.push_back(vec4(-0.77, 0.77, 0, 1)); vertex_positions.push_back(vec4(0, 0, 1, 1)); vertex_positions.push_back(vec4(-0.77, 0.77, 0, 1)); vertex_positions.push_back(vec4(-1, -1, 0, 1)); vertex_positions.push_back(vec4(0, 0, 1, 1)); vertex_positions.push_back(vec4(-0.77, 0.77, 0,1)); vertex_positions.push_back(vec4(1, -1, 0,1)); vertex_positions.push_back(vec4(-1, -1, 0,1)); normalsToVerticesGeneralForm.push_back(vec3(-1, -1, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(1, -1, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(0, 0, 0.8)); normalsToVerticesGeneralForm.push_back(vec3(1, -1, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(-0.77, 0.77, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(0, 0, 0.8)); normalsToVerticesGeneralForm.push_back(vec3(-0.77, 0.77, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(-1, -1, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(0, 0, 0.8)); normalsToVerticesGeneralForm.push_back(vec3(-0.77, 0.77, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(1, -1, -0.2)); normalsToVerticesGeneralForm.push_back(vec3(-1, -1, -0.2)); //normalsToVerticesGeneralForm.push_back(vec3()); colors[0] = vec3(256, 0, 0); colors[1] = vec3(0, 256, 0); colors[2] = vec3(0, 0, 256); colors[3] = vec3(256, 256, 256); GLfloat minX=-1, minY=-1, minZ=0, maxX=1, maxY=0.77, maxZ=1; cube[0] = vec4(minX, minY, minZ, 1.0); cube[1] = vec4(minX, minY, maxZ, 1.0); cube[2] = vec4(minX, maxY, minZ, 1.0); cube[3] = vec4(minX, maxY, maxZ, 1.0); cube[4] = vec4(maxX, minY, minZ, 1.0); cube[5] = vec4(maxX, minY, maxZ, 1.0); cube[6] = vec4(maxX, maxY, minZ, 1.0); cube[7] = vec4(maxX, maxY, maxZ, 1.0); computeNormalsPerFace(); massCenter = vec4(0, 0, 0.4, 1); }