void Pasteboard::writeImage(Element& element, const URL&, const String& title)
{
if (!(element.renderer() && element.renderer()->isRenderImage()))
return;
RenderImage* renderer = toRenderImage(element.renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
m_dataObject->clearAll();
URL url = getURLForImageElement(element);
if (!url.isEmpty()) {
m_dataObject->setURL(url, title);
m_dataObject->setMarkup(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
}
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf());
m_dataObject->setImage(pixbuf.get());
if (m_gtkClipboard)
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_gtkClipboard);
}
void BeginRender()
{
cout<<"\nBeginning Render...";
float alpha = camera.fov;
float l = 1.0;
float h = l * tan(alpha/2.0 *(M_PI/180));
float aspectRatio = (float)camera.imgWidth/camera.imgHeight;
float s = aspectRatio * h;
float dx = (2 * s)/camera.imgWidth;
float dy = -(2 * h)/camera.imgHeight;
float dxx = dx/2,dyy=dy/2;
Point3 K(-s,h,-l);
K.x += dxx;
K.y += dyy;
for(int i = 0; i< camera.imgHeight; i++){
for(int j = 0; j<camera.imgWidth; j++){
K.x += dx;
Matrix3 RotMat;
Point3 dvec = camera.dir - camera.pos;
Point3 svec = camera.up.Cross(dvec);
dvec.Normalize();
svec.Normalize();
camera.up.Normalize();
RotMat.Set(svec,camera.up, dvec);
Ray r(camera.pos, K);
r.dir=r.dir*RotMat;
r.dir.Normalize();
HitInfo hInfo;
hInfo.Init();
if(rootNode.GetNumChild()>0){
// for(int k=0; k < rootNode.GetNumChild(); ++k){
// RayTrace(rootNode.GetChild(k),r,i * camera.imgWidth + j);
// }
if(RayTrace_2(r, hInfo))
{
renderImage.PutPixel(i *camera.imgWidth+j, white, hInfo.z);
}
else renderImage.PutPixel(i *camera.imgWidth+j, black, BIGFLOAT);
}
}
K.x = -s;
K.x += dxx;
K.y += dy;
}
cout<<"Render Complete"<<endl;
renderImage.ComputeZBufferImage();
renderImage.SaveZImage("/Users/varunk/Desktop/RayTracerProj1/RayTracerProj1/zbuffer.ppm");
renderImage.SaveImage("/Users/varunk/Desktop/RayTracerProj1/RayTracerProj1/renderimage.ppm");
}
RenderObject* HTMLPlugInImageElement::createRenderer(RenderArena* arena, RenderStyle* style)
{
// Once a PlugIn Element creates its renderer, it needs to be told when the Document goes
// inactive or reactivates so it can clear the renderer before going into the page cache.
if (!m_needsDocumentActivationCallbacks) {
m_needsDocumentActivationCallbacks = true;
document()->registerForPageCacheSuspensionCallbacks(this);
}
if (displayState() == DisplayingSnapshot) {
RenderSnapshottedPlugIn* renderSnapshottedPlugIn = new (arena) RenderSnapshottedPlugIn(this);
renderSnapshottedPlugIn->updateSnapshot(m_snapshotImage);
return renderSnapshottedPlugIn;
}
// Fallback content breaks the DOM->Renderer class relationship of this
// class and all superclasses because createObject won't necessarily
// return a RenderEmbeddedObject, RenderPart or even RenderWidget.
if (useFallbackContent())
return RenderObject::createObject(this, style);
if (isImageType()) {
RenderImage* image = new (arena) RenderImage(this);
image->setImageResource(RenderImageResource::create());
return image;
}
return new (arena) RenderEmbeddedObject(this);
}
static void appendServerMapMousePosition(StringBuilder& url, Event* event)
{
if (!event->isMouseEvent())
return;
ASSERT(event->target());
Node* target = event->target()->toNode();
ASSERT(target);
if (!isHTMLImageElement(*target))
return;
HTMLImageElement& imageElement = toHTMLImageElement(*target);
if (!imageElement.isServerMap())
return;
if (!imageElement.renderer() || !imageElement.renderer()->isRenderImage())
return;
RenderImage* renderer = toRenderImage(imageElement.renderer());
// FIXME: This should probably pass true for useTransforms.
FloatPoint absolutePosition = renderer->absoluteToLocal(FloatPoint(toMouseEvent(event)->pageX(), toMouseEvent(event)->pageY()));
int x = absolutePosition.x();
int y = absolutePosition.y();
url.append('?');
url.appendNumber(x);
url.append(',');
url.appendNumber(y);
}
void ImageInputType::altAttributeChanged()
{
RenderImage* image = toRenderImage(element()->renderer());
if (!image)
return;
image->updateAltText();
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
ASSERT(node->renderer());
ASSERT(node->renderer()->isImage());
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
// If the image is wrapped in a link, |url| points to the target of the
// link. This isn't useful to us, so get the actual image URL.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
urlString = element->getAttribute(element->imageSourceAttributeName());
}
KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(deprecatedParseURL(urlString));
NativeImageSkia* bitmap = 0;
#if !PLATFORM(CG)
bitmap = image->nativeImageForCurrentFrame();
#endif
ChromiumBridge::clipboardWriteImage(bitmap, url, title);
}
static RenderObject* createRendererForBeforeAfterContent(RenderObject* owner, const ContentData* content, RenderStyle* pseudoElementStyle)
{
RenderObject* renderer = 0;
switch (content->type()) {
case CONTENT_NONE:
break;
case CONTENT_TEXT:
renderer = new (owner->renderArena()) RenderTextFragment(owner->document() /* anonymous object */, static_cast<const TextContentData*>(content)->text().impl());
renderer->setStyle(pseudoElementStyle);
break;
case CONTENT_OBJECT: {
RenderImage* image = new (owner->renderArena()) RenderImage(owner->document()); // anonymous object
RefPtr<RenderStyle> style = RenderStyle::create();
style->inheritFrom(pseudoElementStyle);
image->setStyle(style.release());
if (const StyleImage* styleImage = static_cast<const ImageContentData*>(content)->image())
image->setImageResource(RenderImageResourceStyleImage::create(const_cast<StyleImage*>(styleImage)));
else
image->setImageResource(RenderImageResource::create());
renderer = image;
break;
}
case CONTENT_COUNTER:
renderer = new (owner->renderArena()) RenderCounter(owner->document(), *static_cast<const CounterContentData*>(content)->counter());
renderer->setStyle(pseudoElementStyle);
break;
case CONTENT_QUOTE:
renderer = new (owner->renderArena()) RenderQuote(owner->document(), static_cast<const QuoteContentData*>(content)->quote());
renderer->setStyle(pseudoElementStyle);
break;
}
return renderer;
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = static_cast<RenderImage*>(node->renderer());
CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage());
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
clear();
RefPtr<SharedBitmap> sourceBmp = image->nativeImageForCurrentFrame();
if (!sourceBmp)
return;
IntRect rect(0, 0, sourceBmp->width(), sourceBmp->height());
BitmapInfo bmpInfo;
void* pixels;
HBITMAP resultBitmap = sourceBmp->clipBitmap(rect, true, bmpInfo, pixels);
if (!resultBitmap)
return;
if (::OpenClipboard(m_owner)) {
::SetClipboardData(CF_BITMAP, resultBitmap);
::CloseClipboard();
} else
DeleteObject(resultBitmap);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
NativeImagePtr bitmap = image->nativeImageForCurrentFrame();
if (!bitmap)
return;
// If the image is wrapped in a link, |url| points to the target of the
// link. This isn't useful to us, so get the actual image URL.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
urlString = element->getAttribute(element->imageSourceAttributeName());
}
KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
PlatformSupport::clipboardWriteImage(bitmap, url, title);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
KURL url = getURLForImageNode(node);
if (!url.isEmpty()) {
dataObject->setURL(url, title);
dataObject->setMarkup(createMarkup(static_cast<Element*>(node), IncludeNode, 0, ResolveAllURLs));
}
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf());
dataObject->setImage(pixbuf.get());
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard);
}
static void appendServerMapMousePosition(String& url, Event* event)
{
if (!event->isMouseEvent())
return;
ASSERT(event->target());
Node* target = event->target()->toNode();
ASSERT(target);
if (!target->hasTagName(imgTag))
return;
HTMLImageElement* imageElement = static_cast<HTMLImageElement*>(event->target()->toNode());
if (!imageElement || !imageElement->isServerMap())
return;
RenderImage* renderer = toRenderImage(imageElement->renderer());
if (!renderer)
return;
// FIXME: This should probably pass true for useTransforms.
FloatPoint absolutePosition = renderer->absoluteToLocal(FloatPoint(static_cast<MouseEvent*>(event)->pageX(), static_cast<MouseEvent*>(event)->pageY()));
int x = absolutePosition.x();
int y = absolutePosition.y();
url += "?";
url += String::number(x);
url += ",";
url += String::number(y);
}
void BeginRender()
{
Color24 *temp;
temp = renderImage.GetPixels();
float *zBuffer = renderImage.GetZBuffer();
Color materialColor;
Color24 newColor;
for (int i = 0; i < camera.imgWidth; i++)
{
for (int j = 0; j < camera.imgHeight; j++)
{
Ray currentRay = ComputeCameraRay(i, j);
HitInfo hInfo;
hInfo.Init();
bool value = TraceRay(currentRay, hInfo, &rootNode);
if (value) {
hInfo.node->FromNodeCoords(hInfo);
const Material *m = hInfo.node->GetMaterial();
materialColor = m->Shade(currentRay, hInfo, lights);
temp[camera.imgWidth*j + i].r = (materialColor.r)*255;
temp[camera.imgWidth*j + i].g = (materialColor.g)*255;
temp[camera.imgWidth*j + i].b = (materialColor.b)*255;
}
else {
temp[camera.imgWidth*j + i].r = 0;
temp[camera.imgWidth*j + i].g = 0;
temp[camera.imgWidth*j + i].b = 0;
}
zBuffer[camera.imgWidth*j + i] = hInfo.z;
}
}
renderImage.ComputeZBufferImage();
renderImage.SaveImage("Output");
}
void HTMLObjectElement::attach()
{
HTMLPlugInElement::attach();
if (renderer() && !m_useFallbackContent) {
if (isImageType()) {
if (!m_imageLoader)
m_imageLoader = new HTMLImageLoader(this);
m_imageLoader->updateFromElement();
if (renderer()) {
RenderImage* imageObj = static_cast<RenderImage*>(renderer());
imageObj->setCachedImage(m_imageLoader->image());
}
} else {
if (m_needWidgetUpdate) {
// Set m_needWidgetUpdate to false before calling updateWidget because updateWidget may cause
// this method or recalcStyle (which also calls updateWidget) to be called.
m_needWidgetUpdate = false;
static_cast<RenderPartObject*>(renderer())->updateWidget(true);
} else {
m_needWidgetUpdate = true;
setChanged();
}
}
}
}
void DrawRenderProgressBar()
{
int rp = renderImage.GetNumRenderedPixels();
int np = renderImage.GetWidth() * renderImage.GetHeight();
if ( rp >= np ) return;
float done = (float) rp / (float) np;
DrawProgressBar(done);
}
RenderObject* HTMLEmbedElement::createRenderer(RenderArena* arena, RenderStyle*)
{
if (isImageType()) {
RenderImage* image = new (arena) RenderImage(this);
image->setImageResource(RenderImageResource::create());
return image;
}
return new (arena) RenderEmbeddedObject(this);
}
RenderObject* HTMLImageElement::createRenderer(RenderArena* arena, RenderStyle* style)
{
if (style->hasContent())
return RenderObject::createObject(this, style);
RenderImage* image = new (arena) RenderImage(this);
image->setImageResource(RenderImageResource::create());
return image;
}
static CachedImage* getCachedImage(Element* element)
{
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = static_cast<RenderImage*>(renderer);
return image->cachedImage();
}
void GlutKeyboard(unsigned char key, int x, int y)
{
switch ( key ) {
case 27: // ESC
exit(0);
break;
case ' ':
switch ( mode ) {
case MODE_READY:
mode = MODE_RENDERING;
viewMode = VIEWMODE_IMAGE;
if ( dofImage ) {
Color24 *p = renderImage.GetPixels();
for ( int i=0; i<camera.imgWidth*camera.imgHeight; i++ ) p[i] = dofImage[i];
} else {
DrawScene();
glReadPixels( 0, 0, renderImage.GetWidth(), renderImage.GetHeight(), GL_RGB, GL_UNSIGNED_BYTE, renderImage.GetPixels() );
}
startTime = time(NULL);
BeginRender();
break;
case MODE_RENDERING:
mode = MODE_READY;
StopRender();
glutPostRedisplay();
break;
case MODE_RENDER_DONE:
mode = MODE_READY;
viewMode = VIEWMODE_OPENGL;
glutPostRedisplay();
break;
}
break;
case '1':
viewAngle1 = viewAngle2 = 0;
viewMode = VIEWMODE_OPENGL;
glutPostRedisplay();
break;
case '2':
viewMode = VIEWMODE_IMAGE;
glutPostRedisplay();
break;
case '3':
viewMode = VIEWMODE_Z;
glutPostRedisplay();
break;
case '4':
viewMode = VIEWMODE_SAMPLECOUNT;
glutPostRedisplay();
break;
case '5':
viewMode = VIEWMODE_IRRADCOMP;
glutPostRedisplay();
break;
}
}
RenderObject* ImageContentData::createRenderer(Document& doc, RenderStyle* pseudoStyle) const
{
RenderImage* image = RenderImage::createAnonymous(&doc);
image->setPseudoStyle(pseudoStyle);
if (m_image)
image->setImageResource(RenderImageResourceStyleImage::create(m_image.get()));
else
image->setImageResource(RenderImageResource::create());
return image;
}
RenderObject* HTMLImageElement::createRenderer(RenderStyle* style)
{
if (style->hasContent())
return RenderObject::createObject(this, style);
RenderImage* image = new RenderImage(this);
image->setImageResource(RenderImageResource::create());
image->setImageDevicePixelRatio(m_imageDevicePixelRatio);
return image;
}
void PrintPixelData(int x, int y)
{
if ( x < renderImage.GetWidth() && y < renderImage.GetHeight() ) {
Color24 *colors = renderImage.GetPixels();
float *zbuffer = renderImage.GetZBuffer();
int i = y*renderImage.GetWidth() + x;
printf("Pixel [ %d, %d ] Color24: %d, %d, %d Z: %f\n", x, y, colors[i].r, colors[i].g, colors[i].b, zbuffer[i] );
} else {
printf("-- Invalid pixel (%d,%d) --\n",x,y);
}
}
RenderObject* ImageContentData::createRenderer(Document& document, RenderStyle& pseudoStyle) const
{
// FIXME: We should find a way to avoid setting the style twice here.
RenderImage* image = new RenderImage(document, pseudoStyle);
image->setPseudoStyle(&pseudoStyle);
if (m_image)
image->setImageResource(RenderImageResourceStyleImage::create(*m_image));
else
image->setImageResource(RenderImageResource::create());
return image;
}
static Image* getImage(Element* element)
{
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = toRenderImage(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage()->image();
return 0;
}
RenderObject* HTMLPlugInImageElement::createRenderer(RenderArena* arena, RenderStyle* style)
{
// Fallback content breaks the DOM->Renderer class relationship of this
// class and all superclasses because createObject won't necessarily
// return a RenderEmbeddedObject, RenderPart or even RenderWidget.
if (useFallbackContent())
return RenderObject::createObject(this, style);
if (isImageType()) {
RenderImage* image = new (arena) RenderImage(this);
image->setImageResource(RenderImageResource::create());
return image;
}
return new (arena) RenderEmbeddedObject(this);
}
Image* HitTestResult::image() const
{
if (!m_innerNonSharedNode)
return 0;
RenderObject* renderer = m_innerNonSharedNode->renderer();
if (renderer && renderer->isImage()) {
RenderImage* image = toRenderImage(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage()->imageForRenderer(image);
}
return 0;
}
void HTMLImageElement::attach()
{
HTMLElement::attach();
if (renderer() && renderer()->isImage()) {
RenderImage* imageObj = static_cast<RenderImage*>(renderer());
imageObj->setCachedImage(m_imageLoader.image());
// If we have no image at all because we have no src attribute, set
// image height and width for the alt text instead.
if (!m_imageLoader.image() && !imageObj->cachedImage())
imageObj->setImageSizeForAltText();
}
}
static ImageResource* getImageResource(Element* element)
{
// Attempt to pull ImageResource from element
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = toRenderImage(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage();
return 0;
}
static CachedImage* getCachedImage(Element* element)
{
// Attempt to pull CachedImage from element
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = static_cast<RenderImage*>(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage();
return 0;
}
Image* HitTestResult::image() const
{
if (!m_innerNonSharedNode)
return 0;
auto renderer = m_innerNonSharedNode->renderer();
if (renderer && renderer->isImage()) {
RenderImage* image = static_cast<WebCore::RenderImage*>(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage()->imageForRenderer(image);
}
return 0;
}
void ImageElement::setImageIfNecessary(RenderObject* renderObject, ImageLoader* imageLoader)
{
if (renderObject && renderObject->isImage() && !imageLoader->hasPendingBeforeLoadEvent()) {
RenderImage* renderImage = toRenderImage(renderObject);
RenderImageResource* renderImageResource = renderImage->imageResource();
if (renderImageResource->hasImage())
return;
renderImageResource->setCachedImage(imageLoader->image());
// If we have no image at all because we have no src attribute, set
// image height and width for the alt text instead.
if (!imageLoader->image() && !renderImageResource->cachedImage())
renderImage->setImageSizeForAltText();
}
}
