color trace(ray * primary) {
if (primary->depth > 0) {
VNorm(&primary->d);
reset_intersection(primary->intstruct);
intersect_objects(primary);
return shader(primary);
}
/* if ray is truncated, return the background as its color */
return primary->scene->background;
}
static PyObject* py_glGetShaderInfoLog(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Uint shader(PyTuple_GetItem(args, 0));
GLint len=0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
//GLchar *log = new GLchar[len+1];
Array1D<Char> log(len+1);
glGetShaderInfoLog(shader, len, NULL, log);
return PyString_FromString(log);
//delete[] log;
}
static PyObject* py_glGetShaderSource(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Uint shader(PyTuple_GetItem(args, 0));
GLint len=0;
glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &len);
//GLchar *src = new GLchar[len+1];
Array1D<Char> src(len+1);
glGetShaderSource(shader, len, NULL, src);
return PyString_FromString(src);
//delete[] src;
}
inline Shader ShaderFromLiteral(
ShaderType shader_type,
const char* lit,
size_t size
)
{
Shader shader(shader_type);
shader.Source(StrCRef(lit, size));
shader.Compile();
return shader;
}
inline CoreParticleSystem(CoreEngine* engine, CoreNode* parent) :
engine_(engine),
parent_(parent),
life_(0.0f),
type_(ET_POINT),
accumulator_(0.0f),
frame_id_(0),
inherit_velocity_(true) {
shader("Particle");
}
void TinyRenderer::renderObjectDepth(TinyRenderObjectData& renderData)
{
int width = renderData.m_rgbColorBuffer.get_width();
int height = renderData.m_rgbColorBuffer.get_height();
Vec3f light_dir_local = Vec3f(renderData.m_lightDirWorld[0], renderData.m_lightDirWorld[1], renderData.m_lightDirWorld[2]);
float light_distance = renderData.m_lightDistance;
Model* model = renderData.m_model;
if (0 == model)
return;
renderData.m_viewportMatrix = viewport(0, 0, width, height);
float* shadowBufferPtr = (renderData.m_shadowBuffer && renderData.m_shadowBuffer->size()) ? &renderData.m_shadowBuffer->at(0) : 0;
int* segmentationMaskBufferPtr = 0;
TGAImage depthFrame(width, height, TGAImage::RGB);
{
// light target is set to be the origin, and the up direction is set to be vertical up.
Matrix lightViewMatrix = lookat(light_dir_local * light_distance, Vec3f(0.0, 0.0, 0.0), Vec3f(0.0, 0.0, 1.0));
Matrix lightModelViewMatrix = lightViewMatrix * renderData.m_modelMatrix;
Matrix lightViewProjectionMatrix = renderData.m_projectionMatrix;
Vec3f localScaling(renderData.m_localScaling[0], renderData.m_localScaling[1], renderData.m_localScaling[2]);
DepthShader shader(model, lightModelViewMatrix, lightViewProjectionMatrix, renderData.m_modelMatrix, localScaling, light_distance);
for (int i = 0; i < model->nfaces(); i++)
{
for (int j = 0; j < 3; j++)
{
shader.vertex(i, j);
}
mat<4, 3, float> stackTris[3];
b3AlignedObjectArray<mat<4, 3, float> > clippedTriangles;
clippedTriangles.initializeFromBuffer(stackTris, 0, 3);
bool hasClipped = clipTriangleAgainstNearplane(shader.varying_tri, clippedTriangles);
if (hasClipped)
{
for (int t = 0; t < clippedTriangles.size(); t++)
{
triangleClipped(clippedTriangles[t], shader.varying_tri, shader, depthFrame, shadowBufferPtr, segmentationMaskBufferPtr, renderData.m_viewportMatrix, renderData.m_objectIndex);
}
}
else
{
triangle(shader.varying_tri, shader, depthFrame, shadowBufferPtr, segmentationMaskBufferPtr, renderData.m_viewportMatrix, renderData.m_objectIndex);
}
}
}
}
void canAttachDetachShader()
{
ShaderProgram shaderProgram;
Shader shader(Shader::FRAGMENT_SHADER);
QVERIFY(shaderProgram.attach(shader));
QVERIFY(shaderProgram.has(shader));
QVERIFY(shaderProgram.detach(shader));
QVERIFY(!shaderProgram.has(shader));
}
//----------
void Scene::drawOutlines() {
ofShader & outlineShader(shader("outlineIndex"));
outlineShader.begin();
outlineShader.setUniform1i("elementHover", this->elementUnderCursor);
outlineShader.setUniform1i("nodeSelection", this->nodeSelected);
outlineShader.setUniform1i("nodeHover", this->nodeUnderCursor);
outlineShader.setUniformTexture("texIndex", indexBuffer, 2);
outlineShader.setUniform1i("elementCount", this->elements.size());
outlineShader.setUniform1f("indexScaling", GRABSCENE_INDEX_SCALE);
drawFullscreen(indexBuffer);
outlineShader.end();
}
Color<real> MaterialShader<real>::Shade()
{
// Create the shader depending on the material type
switch( mMaterial.GetMaterialType() )
{
case Material::TypeBlinnPhong:
{
BlinnPhongShader<real> shader( mRayTracer, mScene , static_cast<const BlinnPhongMaterial<real>&>( mMaterial ), mRay, mIntersection, mRecursionDepth );
return shader.Shade();
}
case Material::TypeEnvironment:
{
EnvironmentShader<real> shader( mRayTracer, mScene , static_cast<const EnvironmentMaterial<real>&>( mMaterial ), mRay, mIntersection, mRecursionDepth );
return shader.Shade();
}
}
// If the shader doesn't exist (should never get there)
return Color<real>( 0, 0, 0, 1 );
}
void BoundingBox::draw()
{
// bind the buffers
bufferVBO().bind();
bufferIBO().bind();
// enable the shader attributes (our buffers)
shader()->enableAttributeArray(vertexLocation());
shader()->enableAttributeArray(colorLocation());
// set our buffers into shader
shader()->setAttributeBuffer(vertexLocation(), GL_FLOAT, 0, 3, sizeof(Vertex));
shader()->setAttributeBuffer(colorLocation(), GL_FLOAT, 12, 4, sizeof(Vertex));
// draw primitives
glDrawElements(GL_LINES, indexCount(), GL_UNSIGNED_SHORT, 0);
// disable the shader attributes (our buffers)
shader()->disableAttributeArray(vertexLocation());
shader()->disableAttributeArray(colorLocation());
// release the buffers
bufferVBO().release();
bufferIBO().release();
}
void thread_run(DeviceTask *task)
{
flush_texture_buffers();
if(task->type == DeviceTask::FILM_CONVERT) {
film_convert(*task, task->buffer, task->rgba_byte, task->rgba_half);
}
else if(task->type == DeviceTask::SHADER) {
shader(*task);
}
else if(task->type == DeviceTask::RENDER) {
RenderTile tile;
DenoisingTask denoising(this);
/* Allocate buffer for kernel globals */
device_only_memory<KernelGlobalsDummy> kgbuffer(this, "kernel_globals");
kgbuffer.alloc_to_device(1);
/* Keep rendering tiles until done. */
while(task->acquire_tile(this, tile)) {
if(tile.task == RenderTile::PATH_TRACE) {
assert(tile.task == RenderTile::PATH_TRACE);
scoped_timer timer(&tile.buffers->render_time);
split_kernel->path_trace(task,
tile,
kgbuffer,
*const_mem_map["__data"]);
/* Complete kernel execution before release tile. */
/* This helps in multi-device render;
* The device that reaches the critical-section function
* release_tile waits (stalling other devices from entering
* release_tile) for all kernels to complete. If device1 (a
* slow-render device) reaches release_tile first then it would
* stall device2 (a fast-render device) from proceeding to render
* next tile.
*/
clFinish(cqCommandQueue);
}
else if(tile.task == RenderTile::DENOISE) {
tile.sample = tile.start_sample + tile.num_samples;
denoise(tile, denoising, *task);
task->update_progress(&tile, tile.w*tile.h);
}
task->release_tile(tile);
}
kgbuffer.free();
}
}
void thread_run(DeviceTask *task)
{
if(task->type == DeviceTask::FILM_CONVERT) {
film_convert(*task, task->buffer, task->rgba_byte, task->rgba_half);
}
else if(task->type == DeviceTask::SHADER) {
shader(*task);
}
else if(task->type == DeviceTask::RENDER) {
RenderTile tile;
DenoisingTask denoising(this, *task);
/* Keep rendering tiles until done. */
while(task->acquire_tile(this, tile)) {
if(tile.task == RenderTile::PATH_TRACE) {
int start_sample = tile.start_sample;
int end_sample = tile.start_sample + tile.num_samples;
for(int sample = start_sample; sample < end_sample; sample++) {
if(task->get_cancel()) {
if(task->need_finish_queue == false)
break;
}
path_trace(tile, sample);
tile.sample = sample + 1;
task->update_progress(&tile, tile.w*tile.h);
}
/* Complete kernel execution before release tile */
/* This helps in multi-device render;
* The device that reaches the critical-section function
* release_tile waits (stalling other devices from entering
* release_tile) for all kernels to complete. If device1 (a
* slow-render device) reaches release_tile first then it would
* stall device2 (a fast-render device) from proceeding to render
* next tile.
*/
clFinish(cqCommandQueue);
}
else if(tile.task == RenderTile::DENOISE) {
tile.sample = tile.start_sample + tile.num_samples;
denoise(tile, denoising);
task->update_progress(&tile, tile.w*tile.h);
}
task->release_tile(tile);
}
}
}
void Compass::renderAxisOutline(RenderContext& renderContext, const Mat4x4f& transformation, const Color& color) {
glAssert(glDepthMask(GL_FALSE));
glAssert(glLineWidth(3.0f));
glAssert(glPolygonMode(GL_FRONT, GL_LINE));
ActiveShader shader(renderContext.shaderManager(), Shaders::CompassOutlineShader);
shader.set("Color", color);
renderAxis(renderContext, transformation);
glAssert(glDepthMask(GL_TRUE));
glAssert(glLineWidth(1.0f));
glAssert(glPolygonMode(GL_FRONT, GL_FILL));
}
bool UnlitMaterialSystem::init(Context& context, const MaterialSystemContext& material_system_context)
{
set_layout(StandartGeometryLayout::handle);
if (!context.shader_manager.get(shader(), material_system_context.shader_name))
return false;
transform_uniform_ = context.uniform_pool.create();
UniformBuffer& uniform = context.uniform_pool.get(transform_uniform_);
UniformBufferDesc uniform_buffer_desc;
uniform_buffer_desc.size = sizeof(TransformSimpleData);
uniform_buffer_desc.unit = perframe_data_unit;
return uniform.init(uniform_buffer_desc);
}
//---------
void Handles::Rotate::draw() const {
if (parent == 0 || !this->enabled)
return;
GLboolean hadLighting;
glGetBooleanv(GL_LIGHTING, &hadLighting);
if (hadLighting)
ofDisableLighting();
parent->getNode().transformGL();
ofPushMatrix();
ofScale(scale, scale, scale);
ofPushStyle();
shader("fixed").begin();
this->rotateAxis();
this->setStyleFill();
fill.draw();
this->setStyleLine();
line.draw();
shader("fixed").end();
ofSetColor(255);
if (this->rollover) {
ofTranslate(0, GRABSCENE_HANDLES_RADIUS_1 + GRABSCENE_HANDLES_RADIUS_2 * 2);
ofSetDrawBitmapMode(OF_BITMAPMODE_MODEL_BILLBOARD);
ofDrawBitmapString(this->getReading(), ofPoint());
}
ofPopStyle();
ofPopMatrix();
parent->getNode().restoreTransformGL();
if (hadLighting)
ofEnableLighting();
}
void Application::Update()
{
Shader shader("shaders/texture.vs", "shaders/texture.frag");
Texture texture("textures/texture1.jpg");
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)
};
while (!m_Window.IsClosed())
{
Mesh mesh = MeshGenerator::CreateCube();
Mesh mesh2 = MeshGenerator::CreateCube();
m_Window.Update();
ProcessInput();
shader.Bind();
// Create transformations
glm::mat4 view = m_Camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(glm::radians(m_Camera.GetFOV()), (GLfloat)m_Window.GetWidth() / (GLfloat)m_Window.GetHeight(), m_Camera.GetNear(), m_Camera.GetFar());
// Send matrices to the shader
shader.SetUniform("view", view);
shader.SetUniform("projection", projection);
m_Renderer.Begin();
m_Renderer.AddRenderable(cubePositions[0], glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.5f, 0.5f, 0.5f), &mesh, texture.GetID(), m_Camera.GetFrustum());
m_Renderer.AddRenderable(cubePositions[2], glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), &mesh2, texture.GetID(), m_Camera.GetFrustum());
m_Renderer.End();
m_Renderer.Render();
}
Quit();
}
int run_ex2() {
setup();
// Build and compile our shader program
// Load GLSL Shader Source from File
std::unique_ptr<Shader> shader(
Shader::LoadFromFile("bin/ch1_5_4.vert", "bin/ch1_5.frag"));
vao->bind();
{
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat),
(GLvoid *)0);
glEnableVertexAttribArray(0);
}
vao->unbind();
while (!WINDOWMANAGER.shouldCloseWindow()) {
// Check if any events have been activiated (key pressed, mouse moved etc.)
// and call corresponding response functions
glfwPollEvents();
// Render
// Clear the colorbuffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
shader->activate();
shader->getUniformHandler("xOffset")->uniform1f(0.5f);
vao->bind();
glDrawArrays(GL_TRIANGLES, 0, 3);
vao->unbind();
// Swap the screen buffers
WINDOWMANAGER.swapBuffers();
GLenum err;
err = glGetError();
if (err != GL_NO_ERROR) {
LOG(ERROR) << "OpenGL error detected: 0x" << std::hex << err;
break;
}
}
glfwTerminate();
return 0;
}
/*static*/
SdfPath
UsdImaging_MaterialStrategy::GetBinding(UsdShadeMaterial const& material)
{
TF_DEBUG(USDIMAGING_SHADERS).Msg("\t Look: %s\n",
material.GetPath().GetText());
// ---------------------------------------------------------------------- //
// Hydra-only shader style - displayLook:bxdf
// ---------------------------------------------------------------------- //
if (UsdRelationship matRel = UsdHydraLookAPI(material).GetBxdfRel()) {
TF_DEBUG(USDIMAGING_SHADERS).Msg("\t LookRel: %s\n",
matRel.GetPath().GetText());
UsdShadeShader shader(
UsdImaging_MaterialStrategy::GetTargetedShader(
material.GetPrim(),
matRel));
if (shader) {
TF_DEBUG(USDIMAGING_SHADERS).Msg("\t UsdShade binding found: %s\n",
shader.GetPath().GetText());
return shader.GetPath();
}
}
// ---------------------------------------------------------------------- //
// Deprecated shader style - hydraLook:Surface
// ---------------------------------------------------------------------- //
TfToken hdSurf("hydraLook:surface");
TfToken surfType("HydraPbsSurface");
if (UsdRelationship matRel = material.GetPrim().GetRelationship(hdSurf)) {
TF_DEBUG(USDIMAGING_SHADERS).Msg("\t LookRel: %s\n",
matRel.GetPath().GetText());
if (UsdPrim shader =
UsdImaging_MaterialStrategy::GetTargetedShader(
material.GetPrim(),
matRel)) {
if (TF_VERIFY(shader.GetTypeName() == surfType)) {
TF_DEBUG(USDIMAGING_SHADERS).Msg(
"\t Deprecated binding found: %s\n",
shader.GetPath().GetText());
return shader.GetPath();
}
}
}
return SdfPath::EmptyPath();
}
void ShaderGLTest::addFile() {
#ifndef MAGNUM_TARGET_GLES
Shader shader(Version::GL210, Shader::Type::Fragment);
#else
Shader shader(Version::GLES200, Shader::Type::Fragment);
#endif
shader.addFile(Utility::Directory::join(SHADERGLTEST_FILES_DIR, "shader.glsl"));
#ifndef MAGNUM_TARGET_GLES
CORRADE_COMPARE(shader.sources(), (std::vector<std::string>{
"#version 120\n",
"#line 1 1\n",
"void main() {}\n"
}));
#else
CORRADE_COMPARE(shader.sources(), (std::vector<std::string>{
"#version 100\n",
"#line 1 1\n",
"void main() {}\n"
}));
#endif
}
CScreenSizeQuad::CScreenSizeQuad(void)
{
//generate the cube object
shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/fullscreen_quad_shader.vert");
shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/fullscreen_quad_shader.frag");
shader.CreateAndLinkProgram();
shader.Use();
shader.AddAttribute("vVertex");
shader.AddAttribute("vUV");
shader.AddUniform("textureMap");
glUniform1i(shader("textureMap"), 0);
shader.UnUse();
glm::vec2* vertices=new glm::vec2[4];
vertices[0]=glm::vec2(-1,-1);
vertices[1]=glm::vec2( 1,-1);
vertices[2]=glm::vec2( 1, 1);
vertices[3]=glm::vec2(-1, 1);
total_indices = 2*3;
GLushort* indices = new GLushort[total_indices];
int count = 0;
//fill indices array
GLushort* id=&indices[0];
*id++ = 0; *id++ = 1; *id++ = 2;
*id++ = 0; *id++ = 2; *id++ = 3;
//setup vao and vbo stuff
glGenVertexArrays(1, &vaoID);
glGenBuffers(1, &vboVerticesID);
glGenBuffers(1, &vboIndicesID);
glBindVertexArray(vaoID);
glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID);
glBufferData (GL_ARRAY_BUFFER, 8*sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(shader["vVertex"]);
glVertexAttribPointer(shader["vVertex"], 2, GL_FLOAT, GL_FALSE,0,0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort)*total_indices, &indices[0], GL_STATIC_DRAW);
glBindVertexArray(0);
delete [] indices;
delete [] vertices;
}
Shader loadShader(GLenum type, const FilePath& filepath) {
std::ifstream input(filepath.c_str());
if(!input) {
throw std::runtime_error("Unable to load the file " + filepath.str());
}
std::stringstream buffer;
buffer << input.rdbuf();
Shader shader(type);
shader.setSource(buffer.str().c_str());
return shader;
}
Shader_Ptr& Shader::Load(const std::string& name)
{
ShaderCache::iterator it = s_shaderCache.find(name);
if (it != s_shaderCache.end())
{
return it->second;
}
else
{
Shader_Ptr shader(new Shader(name));
s_shaderCache[name] = shader;
return s_shaderCache[name];
}
}
void testImage(SkCanvas* canvas, SkImage* image) {
SkAutoCanvasRestore acr(canvas, true);
canvas->drawImage(image, 0, 0);
canvas->translate(0, 120);
const SkShader::TileMode tile = SkShader::kRepeat_TileMode;
const SkMatrix localM = SkMatrix::MakeTrans(-50, -50);
SkAutoTUnref<SkShader> shader(image->newShader(tile, tile, &localM));
SkPaint paint;
paint.setAntiAlias(true);
paint.setShader(shader);
canvas->drawCircle(50, 50, 50, paint);
}
NdrNodeDiscoveryResultVec
UsdHydraDiscoveryPlugin::DiscoverNodes(const Context &context)
{
NdrNodeDiscoveryResultVec result;
static std::string shaderDefsFile = _GetShaderResourcePath(
"shaderDefs.usda");
if (shaderDefsFile.empty())
return result;
auto resolverContext = ArGetResolver().CreateDefaultContextForAsset(
shaderDefsFile);
const UsdStageRefPtr stage = UsdStage::Open(shaderDefsFile,
resolverContext);
if (!stage) {
TF_RUNTIME_ERROR("Could not open file '%s' on a USD stage.",
shaderDefsFile.c_str());
return result;
}
ArResolverContextBinder binder(resolverContext);
const TfToken discoveryType(ArGetResolver().GetExtension(
shaderDefsFile));
auto rootPrims = stage->GetPseudoRoot().GetChildren();
for (const auto &shaderDef : rootPrims) {
UsdShadeShader shader(shaderDef);
if (!shader) {
continue;
}
auto discoveryResults = UsdShadeShaderDefUtils::GetNodeDiscoveryResults(
shader, shaderDefsFile);
result.insert(result.end(), discoveryResults.begin(),
discoveryResults.end());
if (discoveryResults.empty()) {
TF_RUNTIME_ERROR("Found shader definition <%s> with no valid "
"discovery results. This is likely because there are no "
"resolvable info:sourceAsset values.",
shaderDef.GetPath().GetText());
}
}
return result;
}
int main(int argc, char *argv[])
{
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);
// set up the usage document, in case we need to print out how to use this program.
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrate support for ARB_vertex_program.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
// construct the viewer.
osgViewer::Viewer viewer;
// add the stats handler
viewer.addEventHandler(new osgViewer::StatsHandler);
std::string shader("simple");
while(arguments.read("-s",shader)) {}
std::string textureFileName("Images/lz.rgb");
while(arguments.read("-t",textureFileName)) {}
std::string terrainFileName("");
while(arguments.read("-d",terrainFileName)) {}
bool dynamic = true;
while(arguments.read("--static")) { dynamic = false; }
bool vbo = false;
while(arguments.read("--vbo")) { vbo = true; }
// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
arguments.getApplicationUsage()->write(std::cout);
return 1;
}
// load the nodes from the commandline arguments.
osg::Node* model = createModel(shader,textureFileName,terrainFileName, dynamic, vbo);
if (!model)
{
return 1;
}
viewer.setSceneData(model);
return viewer.run();
}
void Compass::renderSolidAxis(RenderContext& renderContext, const Mat4x4f& transformation, const Color& color) {
ActiveShader shader(renderContext.shaderManager(), Shaders::CompassShader);
shader.set("CameraPosition", Vec3f(0.0f, 500.0f, 0.0f));
shader.set("LightDirection", Vec3f(0.0f, 0.5f, 1.0f).normalized());
shader.set("LightDiffuse", Color(1.0f, 1.0f, 1.0f, 1.0f));
shader.set("LightSpecular", Color(0.3f, 0.3f, 0.3f, 1.0f));
shader.set("GlobalAmbient", Color(0.2f, 0.2f, 0.2f, 1.0f));
shader.set("MaterialShininess", 32.0f);
shader.set("MaterialDiffuse", color);
shader.set("MaterialAmbient", color);
shader.set("MaterialSpecular", color);
renderAxis(renderContext, transformation);
}
static void
CompileAttachShader(GLProgram &program, GLenum type, const char *code)
{
GLShader shader(type);
shader.Source(code);
shader.Compile();
if (shader.GetCompileStatus() != GL_TRUE) {
char log[4096];
shader.GetInfoLog(log, sizeof(log));
fprintf(stderr, "Shader compiler failed: %s\n", log);
}
program.AttachShader(shader);
}
void Geometry::renderDepthMap(void)
{
// for each triangle - the fill rule is simple opaque black-colored painting
_dxCR( dxSetRenderState( D3DRS_TEXTUREFACTOR, depthColor ) );
_dxCR( dxSetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 ) );
_dxCR( dxSetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR ) );
_dxCR( dxSetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 ) );
_dxCR( dxSetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR ) );
_dxCR( dxSetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE ) );
_dxCR( dxSetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE ) );
int shaderId;
int numAttributes = _mesh->NumAttributeGroups;
for( int i=0; i<numAttributes; i++ )
{
shaderId = _mesh->getAttributeId( i );
if( !shader( shaderId )->isInvisible() )
{
_mesh->renderSubset( i, shader( shaderId ) );
}
}
}
void ShaderGLTest::compile() {
#ifndef MAGNUM_TARGET_GLES
constexpr Version v = Version::GL210;
#else
constexpr Version v = Version::GLES200;
#endif
Shader shader(v, Shader::Type::Fragment);
shader.addSource("void main() {}\n");
CORRADE_VERIFY(shader.compile());
Shader shader2(v, Shader::Type::Fragment);
shader2.addSource("[fu] bleh error #:! stuff\n");
CORRADE_VERIFY(!shader2.compile());
}
void PointHandleHighlightFigure::render(Vbo& vbo, RenderContext& context) {
float factor = context.camera().distanceTo(m_position) * m_scalingFactor;
Mat4f billboardMatrix = context.camera().billboardMatrix();
Mat4f matrix = Mat4f::Identity;
matrix.translate(m_position);
matrix *= billboardMatrix;
matrix.scale(Vec3f(factor, factor, 0.0f));
ApplyMatrix applyBillboard(context.transformation(), matrix);
ActivateShader shader(context.shaderManager(), Shaders::HandleShader);
shader.currentShader().setUniformVariable("Color", m_color);
CircleFigure circle(Axis::AZ, 0.0f, 2.0f * Math::Pi, 2.0f * m_radius, 16, false);
circle.render(vbo, context);
}
